Windows系统Anaconda环境下PyTorch安装报错及运行异常求助

核心解决步骤 #

• 卸载并重装兼容版本的PyTorch

  1. 打开Anaconda Prompt，执行卸载命令：

     conda uninstall torch torchvision torchaudio -y
     

     若之前用pip安装，改用：

     pip uninstall torch torchvision torchaudio -y
     

  2. 根据需求选择安装命令：
     • CPU版（无NVIDIA显卡）：

       conda install pytorch torchvision torchaudio cpuonly -c pytorch
       

     • CUDA版（需匹配显卡CUDA版本，用nvidia-smi查看右上角CUDA版本），例如CUDA 12.1：

       conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia
       

  3. 安装完成后验证：

     import torch
     print(torch.__version__)
     print(torch.cuda.is_available())  # CPU版返回False，CUDA版返回True
     

• 修复Visual C++运行库依赖
  下载并安装微软官方的Visual C++ Redistributable for Visual Studio 2019-2022（x64版本），安装后重启电脑。

• 创建新Anaconda虚拟环境（若环境损坏）

  conda create -n pytorch_env python=3.10 -y
  conda activate pytorch_env
  # 然后执行上面的PyTorch安装命令
  

你的TinyGPT代码修复点 #

代码中generate函数缩进错误，被嵌套在训练循环内部，且return语句放在循环里，导致只能生成1个字符。修正后的代码如下：

import torch
import torch.nn as nn
import torch.nn.functional as F
import math
text = "hello world! transformers are fun."  # Training text
chars = sorted(list(set(text)))
vocab_size = len(chars)

char_to_idx = {ch: i for i, ch in enumerate(chars)}
idx_to_char = {i: ch for i, ch in enumerate(chars)}

data = [char_to_idx[ch] for ch in text]
X = torch.tensor(data[:-1])
Y = torch.tensor(data[1:])

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=100):
        super().__init__()
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1).float()
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0)/d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        self.pe = pe.unsqueeze(0)  # Shape: (1, max_len, d_model)

    def forward(self, x):
        x = x + self.pe[:, :x.size(1)]
        return x

class TinyGPT(nn.Module):
    def __init__(self, vocab_size, d_model=32, nhead=2):
        super().__init__()
        self.embed = nn.Embedding(vocab_size, d_model)
        self.pos_enc = PositionalEncoding(d_model)
        self.transformer_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead)
        self.transformer = nn.TransformerEncoder(self.transformer_layer, num_layers=1)
        self.fc = nn.Linear(d_model, vocab_size)

    def forward(self, x):
        x = self.embed(x).unsqueeze(1)  # (seq_len, batch=1, d_model)
        x = self.pos_enc(x)
        x = self.transformer(x)
        x = self.fc(x.squeeze(1))
        return x

# 修正：将generate函数移到训练循环外
def generate(model, start_char, length=20):
   model.eval()
   idx = char_to_idx[start_char]
   result = start_char
   input_seq = torch.tensor([idx])

   for _ in range(length):
     output = model(input_seq)
     probs = F.softmax(output[-1], dim=0).detach()
     idx = torch.multinomial(probs, 1).item()
     result += idx_to_char[idx]
     input_seq = torch.cat([input_seq, torch.tensor([idx])])  # Append new char
   # 修正：return移出循环
   return result

model = TinyGPT(vocab_size)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(200):
    optimizer.zero_grad()
    output = model(X)
    loss = loss_fn(output, Y)
    loss.backward()
    optimizer.step()

    if epoch % 20 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

print(generate(model, start_char="h", length=30))

内容的提问来源于stack exchange，提问作者Tony Cardinal