pytorch写诗

是的，PyTorch可以用来训练神经网络来生成诗歌。下面是一个基本的示例：

首先，我们需要准备数据和模型。我们可以使用一个著名的诗歌数据集，如唐诗、宋词等。对于模型，我们可以使用一个基于循环神经网络（RNN）的语言模型。

接下来，我们需要定义模型架构和训练循环。在这个例子中，我们使用LSTM作为RNN单元，并且使用交叉熵损失函数来训练模型。我们还可以使用一些技巧来提高生成的诗歌的质量，如温度采样等。

最后，我们可以使用训练好的模型来生成诗歌。我们可以提供一个开头的词或者一些主题，然后让模型自动生成诗歌。

下面是一个简单的PyTorch代码片段，用于训练一个基本的语言模型：

import torch
import torch.nn as nn
import numpy as np

# 准备数据
data = open('poems.txt', 'r').read()
chars = list(set(data))
data_size, vocab_size = len(data), len(chars)
char_to_ix = { ch:i for i,ch in enumerate(chars) }
ix_to_char = { i:ch for i,ch in enumerate(chars) }
sequence_length = 100
num_epochs = 200
hidden_size = 256
learning_rate = 0.01

# 定义模型
class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size
        self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
        self.i2o = nn.Linear(input_size + hidden_size, output_size)
        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, input, hidden):
        combined = torch.cat((input, hidden), 1)
        hidden = self.i2h(combined)
        output = self.i2o(combined)
        output = self.softmax(output)
        return output, hidden

    def init_hidden(self):
        return torch.zeros(1, self.hidden_size)

# 训练模型
rnn = RNN(vocab_size, hidden_size, vocab_size)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(rnn.parameters(), lr=learning_rate)
for epoch in range(num_epochs):
    hidden = rnn.init_hidden()
    loss = 0
    for i in range(0, data_size-sequence_length, sequence_length):
        inputs = [char_to_ix[ch] for ch in data[i:i+sequence_length]]
        targets = [char_to_ix[ch] for ch in data[i+1:i+sequence_length+1]]

        inputs = torch.tensor(inputs, dtype=torch.long).view(-1, 1)
        targets = torch.tensor(targets, dtype=torch.long).view(-1, 1)

        outputs, hidden = rnn(inputs, hidden)
        loss = criterion(outputs, targets)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, data_size-sequence_length, loss.item()))

# 生成诗歌
start_letter = '春'
temperature = 0.5
hidden = rnn.init_hidden()
input = torch.tensor([char_to_ix[start_letter]], dtype=torch.long).view(-1, 1)
output_poem = start_letter
for i in range(100):
    output, hidden = rnn(input, hidden)
    output_dist = output.data.view(-1).div(temperature).exp()
    top_i = torch.multinomial(output_dist, 1)[0]
    predicted_char = ix_to_char[top_i.item()]
    output_poem += predicted_char
    input = torch.tensor([top_i], dtype=torch.long).view(-1, 1)

print(output_poem)

请注意，这只是一个非常基本的示例，您可以使用更复杂的模型和更大的数据集来提高生成的诗歌的质量。