PyTorch学习笔记02

最新推荐文章于 2023-09-15 23:59:27 发布
最新推荐文章于 2023-09-15 23:59:27 发布
阅读量229 收藏 1
点赞数
分类专栏： PyTorch 文章标签： pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Morphine_/article/details/125809935
版权

主要组成模块

​ 在完成一项机器学习任务时的步骤，首先需要对数据进行预处理，其中重要的步骤包括数据格式的统一和必要的数据变换，同时划分训练集和测试集。接下来选择模型，并设定损失函数和优化方法，以及对应的超参数（当然可以使用sklearn这样的机器学习库中模型自带的损失函数和优化器）。最后用模型去拟合训练集数据，并在验证集/测试集上计算模型表现。

​ 深度学习和机器学习在流程上类似，但在代码实现上有较大的差异。首先，由于深度学习所需的样本量很大，一次加载全部数据运行可能会超出内存容量而无法实现；同时还有批（batch）训练等提高模型表现的策略，需要每次训练读取固定数量的样本送入模型中训练，因此深度学习在数据加载上需要有专门的设计。

​ 在模型实现上，深度学习和机器学习也有很大差异。由于深度神经网络层数往往较多，同时会有一些用于实现特定功能的层（如卷积层、池化层、批正则化层、LSTM层等），因此深度神经网络往往需要“逐层”搭建，或者预先定义好可以实现特定功能的模块，再把这些模块组装起来。这种“定制化”的模型构建方式能够充分保证模型的灵活性，也对代码实现提出了新的要求。

​ 接下来是损失函数和优化器的设定。这部分和经典机器学习的实现是类似的。但由于模型设定的灵活性，因此损失函数和优化器要能够保证反向传播能够在用户自行定义的模型结构上实现。

​ 上述步骤完成后就可以开始训练了。我们前面介绍了GPU的概念和GPU用于并行计算加速的功能，不过程序默认是在CPU上运行的，因此在代码实现中，需要把模型和数据“放到”GPU上去做运算，同时还需要保证损失函数和优化器能够在GPU上工作。如果使用多张GPU进行训练，还需要考虑模型和数据分配、整合的问题。此外，后续计算一些指标还需要把数据“放回”CPU。这里涉及到了一系列有关于GPU的配置和操作。

深度学习中训练和验证过程最大的特点在于读入数据是按批的，每次读入一个批次的数据，放入GPU中训练，然后将损失函数反向传播回网络最前面的层，同时使用优化器调整网络参数。这里会涉及到各个模块配合的问题。训练/验证后还需要根据设定好的指标计算模型表现。

1. 基本配置

1.1 包

import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms

1.2 超参数

有如下几个超参数可以设定，方便后续更改

# 配置其他超参数，如batch_size, num_workers, learning_rate以及总的epochs
batch_size = 256 # 批的大小
num_workers = 4  # 线程数
lr = 1e-4        # 学习率
epochs = 20      # 训练轮数
image_size = 28  # 图片尺寸

1.3 GPU的设置

# 方案一：使用os.environ，这种情况如果使用GPU不需要设置
os.environ['CUDA_VISIBLE_DEVICES'] = '0'

# 方案二：使用“device”，后续对要使用GPU的变量用.to(device)即可
device = torch.device("cuda:1" if torch.cuda.is_available() else "cpu")

2. 数据读入

​ PyTorch数据读入是通过Dataset+DataLoader的方式完成的，Dataset定义好数据的格式和数据变换形式，DataLoader用iterative的方式不断读入批次数据。

第一种数据读入方式仅适用于常见的数据集，如MINIST、CIFAR10等，P有Torch官方提供了数据下载，这种方式往往适用于快速测试方法（比如测试某个idea在MINIST数据集上有效）。

第二种数据读入方式需要自己搭建Dataset，这对于PyTorch应用于自己的工作十分重要。

同时，还需要对数据进行必要的变换，比如说需要将图片统一大小，以便后续能够输入网络训练；需要将数据格式转换为Tensor类，等等

这些变换可以很方便的借助torchvision包完成，这是PyTorch官方用于图像处理的工具库，上面提到的使用内置数据集的方式也要使用到。PyTorch的一大方便之处在于它是一套“生态”，有着官方和第三方各个领域的支持。

2.1数据转换

其中“data_transform”可以对图像进行一定的变换，如翻转、裁剪等操作，可自己定义。

from torchvision import transforms

image_size = 28
data_transform = transforms.Compose([
    transforms.ToPILImage(),  # 这一步决定于后续的数据读取方式，如果使用内置数据集则不需要
    transforms.Resize(image_size),
    transforms.ToTensor()
])

2.2 Dataset

  • 针对官方数据集

    from torchvision import datasets

train_data = datasets.FashionMNIST(root='./',
                                   train=True,    			 # 训练集
                                   download=True, 			 # 需要下载
                                   transform=data_transform)  # 数据转换
test_data = datasets.FashionMNIST(root='./',
                                  train=False,				 # 测试集
                                  download=True,
                                  transform=data_transform)

  • 自己的数据集

    我们可以定义自己的Dataset类来实现灵活的数据读取，定义的类需要继承PyTorch自身的Dataset类。主要包含三个函数：

    • __init__: 用于向类中传入外部参数，同时定义样本集
    • __getitem__: 用于逐个读取样本集合中的元素，可以进行一定的变换，并将返回训练/验证所需的数据
    • __len__: 用于返回数据集的样本数

​ 其中图片存放在一个文件夹，另外有一个csv文件给出了图片名称对应的标签。这种情况下需要自己来定义Dataset类：

class FMDataset(Dataset):
    def __init__(self, df, transform=None):
        """
        df:数据
        transform：施加的变化是什么
        """
        self.df = df
        self.transform = transform
        # 提取所有行的从第一列开始往后所有的元素，转换为uint8（图像专属类型）
        self.images = df.iloc[:, 1:].values.astype(np.uint8)
        # 提取所有行的第一列
        self.labels = df.iloc[:, 0].values

    def __len__(self):
        """
        数据集的长度
        """
        return len(self.images)

    def __getitem__(self, idx):
        """
        根据index查找某一条示例
        """
        # 图像信息（这里强行加了一个通道）
        image = self.images[idx].reshape(28, 28, 1)
        # 标签
        label = int(self.labels[idx])
        if self.transform is not None:
            # 如果transform不是None，就对image进行变换
            image = self.transform(image)
        else:
            # 如果不进行transform，就将所有的pixel值除以255方便模型处理
            image = torch.tensor(image / 255, dtype=torch.float)
        label = torch.tensor(label, dtype=torch.long)
        return image, label
# 读取数据集
train_df = pd.read_csv("./fashion-mnist_train.csv")
test_df = pd.read_csv("./fashion-mnist_test.csv")
# 实例化
train_data = FMDataset(train_df, data_transform)
test_data = FMDataset(test_df, data_transform)

2.3 DataLoader

构建好Dataset后，就可以使用DataLoader来按批次读入数据了

train_loader = DataLoader(
    train_data,  # 从哪个Dataset内load data
    batch_size=batch_size,  # 每一批加载多少数据，每次输入多少条数据
    shuffle=True,  # 是否打乱读取
    num_workers=num_workers,  # 使用多少线程读取
    drop_last=True)  # 是否丢掉最后一批数据（在训练的时候最后一批数据往往不到一个batch）

test_loader = DataLoader(test_data,
                         batch_size=batch_size,
                         shuffle=True,
                         num_workers=num_workers)

PyTorch中的DataLoader的读取可以使用next和iter来完成

image, label = next(iter(train_loader))
print(image.shape, label.shape)
plt.imshow(image[0][0], camp='gray')

3. 模型构建

PyTorch中神经网络构造一般是基于 Module 类的模型来完成的，它让模型构造更加灵活。

3.1神经网络的构建

搭建CNN卷积神经网络

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Sequential(      # 卷积操作——序贯模型
            nn.Conv2d(1, 32, 5),        # 2维卷积
            nn.ReLU(),                  # 激活函数
            nn.MaxPool2d(2, stride=2),  # 池化层
            nn.Dropout(0.3),
            nn.Conv2d(32, 64, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3)
        )
        self.fc = nn.Sequential(       # 全连接层
            nn.Linear(64*4*4, 512),    # 从64*4*4到512
            nn.ReLU(),                 # 激活函数
            nn.Linear(512, 10)         # 从512到10
        )

    def forward(self, x):
        x = self.conv(x)
        x = x.view(-1, 64*4*4)         # 拉平便于后续的全连接层操作
        x = self.fc(x)
        # x = nn.functional.normalize(x)
        return x
    
# 模型实例化
model = Net()
model = model.cuda()   # GPU操作（直接.cuda()）

3.2 损失函数

使用torch.nn模块自带的CrossEntropy损失
PyTorch会自动将整型的label转换为one-hot型，用于计算CE loss
这里需要确定label是从0开始的，同时模型不用加softmax层(使用logstic计算)

criterion = nn.CrossEntropyLoss()
# criterion = nn.CrossEntropyLoss(weight=[1,1,1,1,3,1,1,1,1,1])对于4的惩罚加大

3.3 优化器

使用Adam优化器

optimizer = optim.Adam(model.parameters(), lr=0.001)

4. 训练和评估

各自封装成函数，方便后续调用
关注两者的区别

  • 模型状态设置

  • 是否需要出示话优化器

  • 是否需要将loss传回网络

  • 是否需要每步更新optimaizer

  • 模型状态设置

    • model.train()、model.eval()

  • 训练流程：读取、转换、梯度清零、输入、计算损失、反向传播、参数更新

  • 验证流程：读取、转换、输入、计算损失、计算指标

4.1 训练

def train(epoch):
    model.train()  # 训练模式
    train_loss = 0  # loss初始化为0
    for data, label in train_loader:  # 循环所有data_loader
        data, label = data.cuda(), label.cuda()  # 数据放在GPU上
        optimizer.zero_grad  # 将梯度清零，防止梯度回传时累加
        output = model(data)  # 前向传播
        loss = criterion(output, label)  # 损失函数计算
        loss.backward()  # 反向传播
        optimizer.step()  # 优化器更新权重
        train_loss = train_loss / len(train_loader.dataset)
        print(f'Epoch: {epoch} \tTraining Loss: {train_loss}')

4.2评估

def val(eopch):
    model.eval()  # 验证模式
    val_loss = 0
    gt_labels = []  # 正确打标记的
    pred_labels = []  # 预测的结果
    with torch.no_grad():  # 不做梯度的计算
        data, label = data.cuda(), label.cuda()
        output = model(data)
        preds = torch.argmax(output, 1)  # 在10维中求最大的，就是预测结果
        gt_labels.append(label.cpu().data.numpy())
        pred_labels.append(preds.cpu().data.numpy())
        loss = criterion(output, label)  #损失不需要回传了
        val_loss += loss.item() * data * size(0)
    val_loss = val_loss / len(test_loader.dataset)
    gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(
        pred_labels)
    acc = np.sum(gt_labels == pred_labels) / len(pred_labels)
    print(
        f'Epoch: {epoch} \tValidation Loss: {train_loss:6f}, Accuracy: {acc:6f}'
    )

for epoch in range(1, epochs + 1):
    train(epoch)
    val(epoch)

5.完整代码

import os
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms

# 使用os.environ(以后的运算全在GPU进行)
os.environ['CUDA_VISIBLE_DEVICES'] = '0'

# 配置其他超参数，如batch_size, num_workers, learning_rate以及总的epochs
batch_size = 256
num_workers = 4
lr = 1e-4
epochs = 20
image_size = 28

# 设置数据变换
data_transform = transforms.Compose([
    transforms.ToPILImage(),  # 这一步决定于后续的数据读取方式，如果使用内置数据集则不需要
    transforms.Resize(image_size),
    transforms.ToTensor()
])


# 数据读入：读入csv格式的文件，自行构建Dataset类
class FMDataset(Dataset):
    def __init__(self, df, transform=None):
        """
        继承官方的Dataset
        :param df: 数据
        :param transform: 数据变换方式
        """
        self.df = df
        self.transform = transform
        # 提取所有行的从第一列开始往后所有的元素，转换为uint8（图像专属类型）
        self.images = df.iloc[:, 1:].values.astype(np.uint8)
        # 提取所有行的第一列
        self.labels = df.iloc[:, 0].values

    def __len__(self):
        """
        数据集的长度
        """
        return len(self.images)

    def __getitem__(self, idx):
        """
        根据index查找某一条示例
        """
        # 图像信息（这里强行加了一个通道）
        image = self.images[idx].reshape(28, 28, 1)
        # 标签
        label = int(self.labels[idx])
        if self.transform is not None:
            # 如果transform不是None，就对image进行变换
            image = self.transform(image)
        else:
            # 如果不进行transform，就将所有的pixel值除以255方便模型处理
            image = torch.tensor(image / 255, dtype=torch.float)
        label = torch.tensor(label, dtype=torch.long)
        return image, label


# 数据集读取
train_df = pd.read_csv("./fashion-mnist_train.csv")
test_df = pd.read_csv("./fashion-mnist_test.csv")
# 实例化
train_data = FMDataset(train_df, data_transform)
test_data = FMDataset(test_df, data_transform)

# 定义DataLoader的类，以便训练和测试时数据的加载
train_loader = DataLoader(
    train_data,  # 从哪个Dataset内load data
    batch_size=batch_size,  # 每一批加载多少数据，每次输入多少条数据
    shuffle=True,  # 是否打乱读取
    num_workers=num_workers,  # 使用多少线程读取
    drop_last=True)  # 是否丢掉最后一批数据（在训练的时候最后一批数据往往不到一个batch）

test_loader = DataLoader(
    test_data,
    batch_size=batch_size,
    shuffle=True,
    num_workers=num_workers)


# CNN网络搭建
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Sequential(  # 卷积操作——序贯模型
            nn.Conv2d(1, 32, 5),  # 2维卷积
            nn.ReLU(),  # 激活函数
            nn.MaxPool2d(2, stride=2),  # 池化层
            nn.Dropout(0.3),
            nn.Conv2d(32, 64, 5),
            nn.ReLU(),
            nn.MaxPool2d(2, stride=2),
            nn.Dropout(0.3)
        )
        self.fc = nn.Sequential(  # 全连接层
            nn.Linear(64 * 4 * 4, 512),  # 从64*4*4到512
            nn.ReLU(),  # 激活函数
            nn.Linear(512, 10)  # 从512到10
        )

    def forward(self, x):
        x = self.conv(x)
        x = x.view(-1, 64 * 4 * 4)  # 拉平便于后续的全连接层操作
        x = self.fc(x)
        # x = nn.functional.normalize(x)
        return x


# 模型训练
def train(epoch):
    model.train()  # 训练模式
    train_loss = 0  # loss初始化为0
    for data, label in train_loader:  # 循环所有data_loader
        data, label = data.cuda(), label.cuda()  # 数据放在GPU上
        optimizer.zero_grad()  # 将梯度清零，防止梯度回传时累加
        output = model(data)  # 前向传播
        loss = criterion(output, label)  # 损失函数计算
        loss.backward()  # 反向传播
        optimizer.step()  # 优化器更新权重
        train_loss += loss.item() * data.size(0)
    train_loss + train_loss / len(train_loader.dataset)
    print(f'Epoch: {epoch} \tTraining Loss: {train_loss:.6f}')


# 模型评估
def val(eopch):
    model.eval()  # 验证模式
    val_loss = 0
    gt_labels = []  # 正确打标记的
    pred_labels = []  # 预测的结果
    with torch.no_grad():  # 不做梯度的计算
        for data, label in test_loader:
            data, label = data.cuda(), label.cuda()
            output = model(data)
            preds = torch.argmax(output, 1)  # 在10维中求最大的，就是预测结果
            gt_labels.append(label.cpu().data.numpy())
            pred_labels.append(preds.cpu().data.numpy())
            loss = criterion(output, label)  # 损失不需要回传了
            val_loss += loss.item() * data.size(0)
    val_loss = val_loss / len(test_loader.dataset)
    gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(pred_labels)
    acc = np.sum(gt_labels == pred_labels) / len(pred_labels)
    print(
        f'Epoch: {epoch} \tValidation Loss: {val_loss:6f}, Accuracy: {acc:6f}'
    )


if __name__ == '__main__':
    # 模型实例化
    model = Net()
    model = model.cuda()  # GPU操作（直接.cuda()）

    criterion = nn.CrossEntropyLoss()

    optimizer = optim.Adam(model.parameters(), lr=0.001)

    for epoch in range(1, epochs + 1):
        train(epoch)
        val(epoch)
Shannon_Lau
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
解决import torch 报错（虚拟环境中已有pytorch包）问题的历程
weixin_61156398的博客
02-16 2205
解决import torch 报错（虚拟环境中已有pytorch包）问题的历程
PyTorch学习笔记
TSSUS_STARNIGHT的博客
08-08 152
#PyTorch入门 只需要了解Tensor（张量）这种数据结构即可，具体可以看 链接: link.
Pytorch学习之神经网络参数管理
ting_qifengl的博客
05-25 2558
这里记录一下pytorch神经网络参数管理方法(参数访问、参数初始化、参数绑定)，方便自己和需要的朋友学习、查阅。 一、参数访问 1.1 访问指定层的指定参数 首先构建一个多层感知机。 import torch from torch import nn net = nn.Sequential(nn.Linear(2, 4), nn.ReLU(), nn.Linear(4, 1)) X = torch.rand(size=(2, 2)) 当通过nn.Sequential定义模型时， 我们可以通过
pytorch简单案例
qq_62678867的博客
09-11 1224
使用pytorch做了一个非常简单的线性回归模型和一个单分类模型
PyTorch实战案例（一）——利用PyTorch实现线性回归算法（基础）
Wendy的博客
11-05 3619
目录一、案例描述二、代码详解2.1 根据直线方程构造数据集2.2 构建数据迭代器2.3 构建神经网络层并进行初始化2.4 开始训练2.5 输出结果验证三、完整代码 一、案例描述 学习一门编程语言最快速的途径便是学习案例，然后自己再独立去实现案例，本文将介绍PyTorch的第一个实战案例——线性回归算法。 案例为：利用PyTorch设计神经网络拟合直线y=Wx+b，其中W=[2,-3.4]T ， b=4.2。 该案例有两个特征，分别是W的两个维度，有一个标签，为输出y。 二、代码详解 2.1 根据直线方
Jupyter中安装深度学习pytorch框架并import torch测试
m0_48545452的博客
02-27 1万+
介绍了自己安装pytorch并嵌入到jupyter种遇到的问题、总结了该过程的注意事项以及解决方法。
PyTorch 学习笔记
weixin_36315698的博客
04-11 839
在复现Face Xray论文遇到的问题记录： 数据预处理部分—获取训练数据的label xray图片 1、用opencv-python求图片的轮廓（凸包） 对于Deepfakes，已知bbox坐标信息即人脸修改区域，直接绘制四点的凸包获取修改边缘： xray_img = np.zeros((facesize, facesize, 3), dtype=np.uint8) points = np.ar...
pytorch学习笔记
07-15
pytorch学习笔记
pytorch 学习笔记
06-27
pytorch 学习笔记
笔记pytorch学习笔记
07-20
【PyTorch学习笔记概述】 PyTorch是Facebook开源的一款深度学习框架，它以其灵活性、易用性和强大的计算能力在学术界和工业界都受到了广泛的欢迎。本笔记将基于B站牛二大人的讲解，深入探讨PyTorch的核心概念、基本...
pytorch学习笔记（一）
01-06
此为小弟pytorch的学习笔记，希望自己可以坚持下去。（2020/2/17） pytorch官方文档 pytorch中文教程 tensor tensor是pytorch的最基本数据类型，相当于numpy中的ndarray，并且属性和numpy相似，tensor可在GPU上进行...
模糊时间的柔性车间调度问题-Python实现遗传算法求解
太剧烈的快乐与太剧烈的悲哀是有相同之点的——同样地需要远离人群！
05-04 3262
1 问题描述 FJSPF（the FJSP with Fuzzy Processing time）可以表述如下：有n 个工件要在 m 台机器上加工。每个工件有ni个工序，每个工件必须按确定的路径完成所有工序，每道工序有1台及以上加工工序，工序的加工时间为模糊时间。 1.1 模糊加工时间的运算 当工序加工时间为模糊时间时，要想能很好的排产出来，比如在甘特图上排产，需要一些模糊数运算操作。这些运算包括加法运算、两个模糊数的最大运算和模糊数的排序方法。加法运算用于计算运算的模糊完成时间。最大....
torch学习笔记
qq_43420530的博客
12-21 974
关于tensor tensor.data是属性，tensor.detach()是方法，返回的数据与原数据是共享的，一者改变另一者也跟着改变；并且默认都是不跟踪梯度，但是tensor.data这样会有风险，因为可能在某个地方数据改变了而我不知道，而detach()设置跟踪梯度之后可以规避风险；我们还可以使用类似NumPy的索引操作来访问Tensor的一部分，需要注意的是：索引出来的结果与原数据共享内存，也即修改一个，另一个会跟着修改 tensor默认不追踪梯度 tensor.clone()函数返回一个克隆，
安装Anaconda与pytorch，在IDEA中配置环境进行编程
最新发布
m1751250104的博客
09-15 3171
若最新pytroch版本没有适配版本（大于或等于当前已安装cuda版本），进入先前版本寻找，以下是适合我GPU的版本。cdm中输入nvidia-smi即可查看GPU和CUDA适配版本。安装完毕后在创建的虚拟环境pytorch中检验是否安装成功。输入得到的conda版pytorch下载命令。与自己python版本不否请查找自己版本。之后Anaconda Prompt中输入。安装中有pytorch后输入y确认安装。在询问时输入y进行下载。获得conda下载命令。
pytorch使用踩坑import torchvision
X2212450371xyz的博客
03-18 4125
很久之前在ubuntu上配置了pytorch环境，最近在windows系统下重新安装的了pytorch，踩了坑耽误很多时间，现总结如下 import torchvision出错 安装环境：anaconda+pytorch+cuda10.0+cudnn 安装成功后import torch正常，但是import torchvision提示报错，其中错误原因是 cannot import name 'P...
python pytorch import error_import torch报错完美解决！
weixin_35065221的博客
01-13 3478
import torch报错：from torch._C import * ImportError: DLL load failed: 找不到指定的程序，完美解决！1. 问题描述昨天刚收到新买的笔记本电脑，就迫不及待的着手安装Pytorch。首先安装了Ananconda一切顺利，但是当我用conda命令安装完pytorch，在命令行输入"import torch"后发现报错，错误提示为：“impo...
Pytorch 入门
Sakurs的博客
11-22 983
Pytorch 基本元素的操作 创建一个矩阵的操作 import torch x = torch.empty(5,3) if __name__ == '__main__': print(x) 创建一个有初始化的矩阵： y = torch.rand(2,4) y_1 = torch.randn(2,4) if __name__ == '__main__': print(y) print(y_1) 对比有初始化和无初始化的矩阵时，当声明一个未初..
pytorch下import torch_PyTorch（二）
weixin_39868034的博客
11-21 1330
依然采取自顶向下的原则剖析，借助PyTorch的python接口。我们知道使用PyTorch第一步都是import torch于是阅读torch/__init__.py，发现需要加载torch._C这个库，但是需要以（RTLD_GLOBAL|RTLD_LAZY）这个模式动态加载，于是先将动态加载模式设置到（RTLD_GLOBAL|RTLD_LAZY）之后加载torch._C然后再恢复动态加载模式，...
Pycharm中import torch报错，python中import torch不报错
热门推荐
weixin_45654744的博客
12-11 3万+
前言： 我目前已有的配置： Windows10 + Anaconda3 + Python 3.8 + CUDA10.2 + cuDNN 最近在跑一个人眼视线的模型，需要import torch， torchvision. 我之前已经在pytorch环境中安装了pytorch 和torchvision了，打开Anaconda prompt, 在python中可以import torch 和 torchvision，但是在pycharm中始终无法import. 后面寻找原因，发现了两个问题： 我的CUDA,

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值