python使用torch 库简单举例
时间: 2023-09-16 14:13:35 浏览: 63
好的,以下是一个简单的使用 PyTorch 库的例子:
```
import torch
# 创建一个张量
x = torch.tensor([[1, 2], [3, 4]])
# 打印张量
print(x)
# 创建一个全零张量
y = torch.zeros((2, 2))
# 打印全零张量
print(y)
# 相加
z = x + y
# 打印相加后的结果
print(z)
```
这个例子展示了如何使用 PyTorch 创建一个张量,并且打印出来。另外,我们创建了一个全零张量,然后将两个张量相加,最后打印出相加后的结果。
相关问题
使用Python代码举例说明
好的,下面是一个使用ChitGPT进行对话的Python代码示例:
```python
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
# 加载预训练模型和分词器
model = AutoModelForCausalLM.from_pretrained("chitgpt/small")
tokenizer = AutoTokenizer.from_pretrained("chitgpt/small")
# 开始对话
while True:
user_input = input("你: ")
input_ids = tokenizer.encode(user_input + tokenizer.eos_token, return_tensors="pt")
bot_output = model.generate(input_ids, max_length=1000, pad_token_id=tokenizer.eos_token_id)
bot_response = tokenizer.decode(bot_output[0], skip_special_tokens=True)
print("ChitGPT: " + bot_response)
```
这个代码使用了HuggingFace的Transformers库,首先加载了ChitGPT的预训练模型和分词器,然后通过一个while循环不断地接受用户输入,将用户输入编码成模型可以接受的格式,并使用模型生成回复,最后将回复解码并输出给用户。
python代码生成language model举例
下面是一个简单的Python示例,用于生成语言模型的代码:
```python
import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.datasets import WikiText2
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
from torch.utils.data import DataLoader
from torch.nn.utils import clip_grad_norm_
# 加载WikiText-2数据集
train_dataset, valid_dataset, test_dataset = WikiText2.splits(text_field='text')
# 建立词汇表
tokenizer = get_tokenizer('basic_english')
vocab = build_vocab_from_iterator(map(tokenizer, iter(train_dataset)), specials=['<unk>', '<pad>', '<bos>', '<eos>'], min_freq=10)
# 定义模型
class LanguageModel(nn.Module):
def __init__(self, vocab_size, embedding_size, hidden_size, num_layers, dropout):
super(LanguageModel, self).__init__()
self.embedding = nn.Embedding(vocab_size, embedding_size)
self.lstm = nn.LSTM(embedding_size, hidden_size, num_layers, dropout=dropout)
self.fc = nn.Linear(hidden_size, vocab_size)
def forward(self, x, hidden):
x = self.embedding(x)
output, hidden = self.lstm(x, hidden)
output = self.fc(output.view(output.size(0)*output.size(1), output.size(2)))
return output, hidden
def init_hidden(self, batch_size):
return (torch.zeros(self.num_layers, batch_size, self.hidden_size),
torch.zeros(self.num_layers, batch_size, self.hidden_size))
# 定义超参数
batch_size = 32
embedding_size = 128
hidden_size = 256
num_layers = 2
dropout = 0.2
lr = 0.001
epochs = 10
# 初始化模型、损失函数和优化器
model = LanguageModel(len(vocab), embedding_size, hidden_size, num_layers, dropout)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=lr)
# 训练模型
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
for epoch in range(epochs):
model.train()
hidden = model.init_hidden(batch_size)
for i, batch in enumerate(train_loader):
x, y = batch.text.t().contiguous().cuda(), batch.target.t().contiguous().cuda()
hidden = tuple(h.detach() for h in hidden)
optimizer.zero_grad()
output, hidden = model(x, hidden)
loss = criterion(output, y.view(-1))
loss.backward()
clip_grad_norm_(model.parameters(), 0.5)
optimizer.step()
if i % 100 == 0:
print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, epochs, i+1, len(train_loader), loss.item()))
# 使用模型生成文本
model.eval()
hidden = model.init_hidden(1)
x = torch.tensor([vocab.stoi['<bos>']]).unsqueeze(1).cuda()
tokens = []
for i in range(100):
output, hidden = model(x, hidden)
output = output[-1,:].div(0.8).exp().cpu()
token = torch.multinomial(output, 1)[0]
x.fill_(token)
tokens.append(token)
text = ' '.join([vocab.itos[token] for token in tokens])
print(text)
```
这段代码使用 PyTorch 和 TorchText 库加载 WikiText-2 数据集,并使用 torchtext.vocab 库建立词汇表。然后,它定义了一个语言模型类,包括嵌入层、LSTM层和全连接层。接下来,它定义了超参数,初始化模型、损失函数和优化器,然后使用 DataLoader 迭代训练数据集,训练模型。最后,它使用训练好的模型生成文本。