django-admin startproject auto_poetry
cd auto_poetry

python manage.py startapp poetry

import jieba

def preprocess_poetry(poetry):
    # 对诗歌进行分词处理
    words = jieba.lcut(poetry)
    return words

# 载入诗歌数据并预处理
poetry_data = []
with open('poetry_data.txt', 'r', encoding='utf-8') as f:
    for line in f.readlines():
        poetry_data.append(preprocess_poetry(line.strip()))

import torch
import torch.nn as nn

class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

import numpy as np

def create_dataset(data, seq_length):
    sequences = []
    for line in data:
        if len(line) > seq_length:
            for i in range(len(line) - seq_length):
                seq = line[i:i + seq_length]
                sequences.append(seq)
    return sequences

# 定义序列长度
seq_length = 5
# 创建数据集
sequences = create_dataset(poetry_data, seq_length)

# 构建输入和标签数据
X = np.zeros((len(sequences), seq_length, len(vocab)))
for i, seq in enumerate(sequences):
    for j, char in enumerate(seq):
        X[i, j, vocab[char]] = 1
X = torch.from_numpy(X).float()

# 定义超参数
input_size = len(vocab)
hidden_size = 128
num_layers = 2
output_size = len(vocab)
num_epochs = 100
learning_rate = 0.001

# 实例化模型
model = LSTMModel(input_size, hidden_size, output_size, num_layers).to(device)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 模型训练
for epoch in range(num_epochs):
    outputs = model(X)
    loss = criterion(outputs, Y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

def generate_acrostic_poetry(model, vocab, start_words, temperature=1.0):
    model.eval()
    poem = ''
    for start_word in start_words:
        with torch.no_grad():
            input = torch.zeros(1, seq_length, len(vocab))
            input[0][0][vocab[start_word]] = 1
            for i in range(1, seq_length):
                output = model(input)
                word_idx = sample_next_word(output[0], temperature)
                poem += list(vocab.keys())[list(vocab.values()).index(word_idx)]
                input[0][i][word_idx] = 1
    return poem

def generate_continuation(model, vocab, start_sentence, temperature=1.0):
    model.eval()
    sentence = start_sentence
    with torch.no_grad():
        input = torch.zeros(1, seq_length, len(vocab))
        for i, char in enumerate(start_sentence[:-1]):
            input[0][i][vocab[char]] = 1
        for i in range(len(start_sentence) - 1, seq_length):
            output = model(input)
            word_idx = sample_next_word(output[0], temperature)
            sentence += list(vocab.keys())[list(vocab.values()).index(word_idx)]
            input = input[:, 1:]
            new_input = torch.zeros(1, 1, len(vocab))
            new_input[0][0][word_idx] = 1
            input = torch.cat((input, new_input), dim=1)
    return sentence

def sample_next_word(output, temperature=1.0):
    output_dist = output.div(temperature).exp()
    top_i = torch.multinomial(output_dist, 1)[0].item()
    return top_i

from django.shortcuts import render
from .models import PoetryModel

def generate_acrostic(request):
    if request.method == 'POST':
        start_words = request.POST['start_words']
        generated_poetry = generate_acrostic_poetry(model, vocab, start_words)
        return render(request, 'poetry/generated_poetry.html', {'poetry': generated_poetry})
    return render(request, 'poetry/generate_acrostic.html')

def generate_continuation(request):
    if request.method == 'POST':
        start_sentence = request.POST['start_sentence']
        generated_sentence = generate_continuation(model, vocab, start_sentence)
        return render(request, 'poetry/generated_sentence.html', {'sentence': generated_sentence})
    return render(request, 'poetry/generate_continuation.html')

<!-- generate_acrostic.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Generate Acrostic Poetry</title>
</head>
<body>
    <h1>Generate Acrostic Poetry</h1>
    <form method="post">
        {% csrf_token %}
        <input type="text" name="start_words" placeholder="Enter start words">
        <button type="submit">Generate</button>
    </form>
</body>
</html>

<!-- generated_poetry.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Generated Poetry</title>
</head>
<body>
    <h1>Generated Poetry</h1>
    <p>{{ poetry }}</p>
</body>
</html>

<!-- generate_continuation.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Generate Continuation</title>
</head>
<body>
    <h1>Generate Continuation</h1>
    <form method="post">
        {% csrf_token %}
        <input type="text" name="start_sentence" placeholder="Enter start sentence">
        <button type="submit">Generate</button>
    </form>
</body>
</html>

<!-- generated_sentence.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Generated Sentence</title>
</head>
<body>
    <h1>Generated Sentence</h1>
    <p>{{ sentence }}</p>
</body>
</html>

python manage.py runserver