上下文无关文法序列

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

def generate_data(num_samples):
data = []
for _ in range(num_samples):
n = 30 # 固定n为30
seq = [0]n + [1]n
data.append(seq)
return data

def preprocess_data(data, max_len):
padded = [seq + [2]*(max_len - len(seq)) for seq in data]
return torch.tensor(padded, dtype=torch.long)

class RNNGenerator(nn.Module):
def init(self, vocab_size, hidden_size, num_layers):
super().init()
self.embedding = nn.Embedding(vocab_size, hidden_size)
self.rnn = nn.LSTM(hidden_size, hidden_size, num_layers, batch_first=True)
self.fc = nn.Linear(hidden_size, vocab_size)

def forward(self, x, hidden=None):x = self.embedding(x)out, hidden = self.rnn(x, hidden)out = self.fc(out)return out, hidden

vocab_size = 3
hidden_size = 64 # 增大隐藏层适配长序列
num_layers = 2 # 增加层数提升建模能力
max_len = 60 # 0³⁰⁺¹30总长度60
model = RNNGenerator(vocab_size, hidden_size, num_layers)
criterion = nn.CrossEntropyLoss(ignore_index=2)
optimizer = optim.Adam(model.parameters(), lr=0.001)

data = generate_data(500) # 生成500条训练样本
padded_data = preprocess_data(data, max_len)

for epoch in range(200): # 增加训练轮数
model.train()
optimizer.zero_grad()
x = padded_data[:, :-1]
y = padded_data[:, 1:]
out, _ = model(x)
loss = criterion(out.reshape(-1, vocab_size), y.reshape(-1))
loss.backward()
optimizer.step()
if (epoch+1) % 20 == 0:
print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

model.eval()
with torch.no_grad():
start = torch.tensor([[0]], dtype=torch.long)
hidden = None
seq = [0]
for _ in range(59): # 生成后续59个字符（总长度60）
out, hidden = model(start, hidden)
pred = out.argmax(dim=-1).item()
seq.append(pred)
start = torch.tensor([[pred]], dtype=torch.long)
print("生成的0³⁰¹30序列：", seq)