请给我一个做nlg的RNN例子，并附上代码讲解可以吗

当然可以，以下是一个简单的基于RNN的自然语言生成模型的代码实现。

首先，我们需要准备训练数据。这里我们使用一个简单的数据集，其中每个样本都是一个句子，如下所示：

I am happy.
She is sad.
He is angry.

接下来，我们需要将这些句子转换为计算机能够理解的向量表示。为此，我们可以使用词袋模型，将每个单词表示为一个独热向量，然后将整个句子表示为所有单词向量的平均值。代码如下：

import numpy as np

def create_dataset(sentences):
    # Create word-to-index dictionary
    word_to_idx = {}
    for sentence in sentences:
        for word in sentence.split():
            if word not in word_to_idx:
                word_to_idx[word] = len(word_to_idx)
    
    # Create dataset
    dataset = []
    for sentence in sentences:
        sentence_vec = np.zeros(len(word_to_idx))
        for word in sentence.split():
            sentence_vec[word_to_idx[word]] = 1
        dataset.append(sentence_vec)
    
    return dataset, word_to_idx

sentences = ["I am happy.", "She is sad.", "He is angry."]
dataset, word_to_idx = create_dataset(sentences)

接下来，我们可以构建我们的RNN模型。这里我们使用一个简单的单层LSTM网络。

import torch
import torch.nn as nn

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size
        
        self.lstm = nn.LSTM(input_size, hidden_size)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, input):
        h0 = torch.zeros(1, 1, self.hidden_size)
        c0 = torch.zeros(1, 1, self.hidden_size)
        output, _ = self.lstm(input.view(len(input), 1, -1), (h0, c0))
        output = self.fc(output.view(len(input), -1))
        return output[-1]

现在我们可以开始训练我们的模型。由于我们的目标是生成一个句子，所以我们将网络的输出解释为每个单词的概率分布，然后使用softmax函数将其转换为概率。代码如下：

import torch.optim as optim

# Build model
input_size = len(word_to_idx)
hidden_size = 128
output_size = len(word_to_idx)
rnn = RNN(input_size, hidden_size, output_size)

# Train model
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(rnn.parameters(), lr=0.1)

for epoch in range(1000):
    for sentence in dataset:
        rnn.zero_grad()
        
        input = torch.tensor(sentence[:-1], dtype=torch.float32)
        target = torch.tensor(sentence[1:], dtype=torch.long)
        
        output = rnn(input)
        loss = criterion(output, target)
        
        loss.backward()
        optimizer.step()
    
    if epoch % 100 == 0:
        print("Epoch {0}, Loss {1}".format(epoch, loss.item()))

最后，我们可以使用训练好的模型生成新的句子。为此，我们从一个随机单词开始，然后多次调用模型来预测下一个单词，直到我们达到了句子的最大长度。代码如下：

max_length = 10

def generate_sentence(rnn, word_to_idx):
    # Choose random starting word
    idx_to_word = {i: w for w, i in word_to_idx.items()}
    input = torch.zeros(len(word_to_idx))
    start_idx = np.random.randint(len(word_to_idx))
    input[start_idx] = 1
    
    # Generate sentence
    sentence = [idx_to_word[start_idx]]
    for i in range(max_length):
        output = rnn(input)
        output_dist = nn.functional.softmax(output, dim=0)
        idx = torch.argmax(output_dist).item()
        input.zero_()
        input[idx] = 1
        sentence.append(idx_to_word[idx])
        if idx == word_to_idx["."]:
            break
    
    return " ".join(sentence)

for i in range(5):
    print(generate_sentence(rnn, word_to_idx))

这就是一个简单的基于RNN的自然语言生成模型的代码实现。当然，这只是一个基础模型，还有很多改进的空间。