已经知道语料和词向量，预训练模型完整源码，可运行

好的，这里提供一个完整的基于PyTorch的预训练模型源码示例，可直接运行：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# 定义超参数
batch_size = 64
embedding_dim = 100
hidden_dim = 256
num_layers = 2
learning_rate = 0.001
num_epochs = 10

# 定义语料和词向量
corpus = ['i like playing football',
          'he likes playing basketball',
          'she hates playing volleyball',
          'they enjoy playing tennis',
          'we love playing hockey']
words = []
for sentence in corpus:
    for word in sentence.split():
        if word.lower() not in words:
            words.append(word.lower())
        
word_to_idx = {word: i for i, word in enumerate(words)}
idx_to_word = {i: word for i, word in enumerate(words)}

# 定义数据集和数据加载器
class TextDataset(Dataset):
    def __init__(self, corpus, word_to_idx):
        self.corpus = corpus
        self.word_to_idx = word_to_idx
        
    def __len__(self):
        return len(self.corpus)
    
    def __getitem__(self, idx):
        sentence = self.corpus[idx]
        inputs = [self.word_to_idx[word.lower()] for word in sentence.split()[:-1]]
        target = self.word_to_idx[sentence.split()[-1].lower()]
        return torch.tensor(inputs), torch.tensor(target)

dataset = TextDataset(corpus, word_to_idx)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 定义模型
class LanguageModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers):
        super(LanguageModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, vocab_size)
        
    def forward(self, x, h):
        x = self.embedding(x)
        x, h = self.lstm(x, h)
        x = self.fc(x)
        return x, h

# 定义损失函数和优化器
model = LanguageModel(len(words), embedding_dim, hidden_dim, num_layers)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 开始训练
for epoch in range(num_epochs):
    running_loss = 0.0
    h = None
    for i, (inputs, target) in enumerate(dataloader):
        # 前向传播和计算损失
        optimizer.zero_grad()
        output, h = model(inputs, h)
        loss = criterion(output.view(-1, len(words)), target.view(-1))
        running_loss += loss.item()
        
        # 反向传播和更新参数
        loss.backward()
        optimizer.step()
        
    # 打印损失和示例输出
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, running_loss/len(dataloader)))
    inputs = torch.tensor([word_to_idx['i'], word_to_idx['like']])
    h = None
    for j in range(3):
        output, h = model(inputs.unsqueeze(0), h)
        _, predicted = torch.max(output.data, 2)
        print(idx_to_word[inputs[0].item()], end=' ')
        inputs = predicted.squeeze().detach()
    print('')

这个预训练模型使用了一个双层LSTM网络来学习语料中的单词关系，并通过交叉熵损失函数来优化模型参数。在训练过程中，每个输入数据是一个单词序列，目标数据是输入序列中下一个单词。在测试过程中，可以输入一个单词序列，输出它的下一个单词。