01深度学习——pyTorch安装与使用_pytorch安装使用

1 pytorch安装

根据需要选择对应的安装方式，推荐使用pip（速度较快）；推荐stable版本，preview版本较新，可能不稳定。；

最新的pytorch一般需要对应最新的python，可以根据python安装对应的版本。下面这个就需要python3.8以上的版本。

地址：PyTorch

网络不好的时候可以下载到本地，在文件所在位置打开命令窗口，输入安装指令：

pip install 文件名

2 api文档查看

【布客】PyTorch 中文翻译 (apachecn.org)

3 pytorch的使用方法

3.1 pytorch是什么

pytorch是一个基于python的科学计算工具包，主要面向两种场景：

1、用于替代Numpy  ，可以使用GPU的计算力；

2、使用深度学习的研究平台，可以提供最大的灵活性和速度。

3.2 tensors

tensors(张量)类似于ndarrays，不过tensors还可以运行于GPU上以提升计算速度

3.3 Numpy转换

将torch中的张量转换为numpy中的数组或者反过来；torch张量与numpy数组将共享他们底层的内存位置，改变二者将会改变另一个

#****torch与numpy互转
x=torch.Tensor(5,3)
a=x.numpy()#tensors转ndarray
b=torch.from_numpy(a)#numpy转torch

3.4CUDA张量

使用.cuda函数可以将张量移到GPU上进行计算

#cuda使用
x=torch.rand(5,2)
y=torch.rand(5,2)
if torch.cuda.is_available():
    x = x.cuda()
    y = y.cuda()
    #x=x.cpu()   在算损失的时候需要转回CPU  只有在同一个位置才可以做运算  默认都是CPU，只有点了cuda之后才会在GPU上运算
    print("GPU")
else:
    print("CPU")
print(x+y)

3.5Autograd:自动求导

pytorch中所有神经网络的核心是autograd包

autograd包为张量上的所有操作提供了自动求导，它是一个运行时定义的框架，这意味着方向传播是根据你的代码如何运行来定义，并且每次迭代可以不同。

变量（variable）

aotugrad.variable是autograd包的核心类。它包装了张量（tensor)，支持几乎所有的张量上的操作。完成前向计算，可以通过.backward()方法自动计算所有的梯度。

可以通过.data属性访问变量中的原始张量，关于这个变量的梯度被计算放入.grad属性中。

#variable自动求导
x1=Variable(torch.randn(2,2,2))
print(x1)
x2=x1+2
print(x2)
#variable可以自动求导，但是需要申请权限（require grad），不申请权限无法求导
y1=Variable(torch.ones(2,2,2),requires_grad=True)
y2=y1+2
#求导只可以求标量的导，不能对张量或则矩阵求导
#y1.backward()
g=y2.mean()
g.backward()
 
#取出张量中的数字
print(g.item())

输出

tensor([[[-1.4678, -1.0724],
         [ 1.5265, -0.5465]],
 
        [[-0.2039,  1.0672],
         [ 0.5085, -0.6216]]])
tensor([[[0.5322, 0.9276],
         [3.5265, 1.4535]],
 
        [[1.7961, 3.0672],
         [2.5085, 1.3784]]])
3.0

3.6 辅助功能

示例数据集下载使用

import torchvision#数据集  放在辅助模块
import torch.utils.data as data#加载数据集放在主模块
"""
# #导入数据集  一般设置四个参数   root：位置
# train:是否训练集
# download：是否下载
# transform:转换为张量
"""
train_data=torchvision.datasets.MNIST(
    root='./data',
    train=True,
    download=True,
    transform=torchvision.transforms.ToTensor()
)
test_data=torchvision.datasets.MNIST(
    root='./data',
    train=False,
    download=False,
    transform=torchvision.transforms.ToTensor()
)
print("train_data:",train_data.data.size())

输出

  warn(
Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data\MNIST\raw\train-images-idx3-ubyte.gz
100%|██████████| 9912422/9912422 [00:04<00:00, 2365825.63it/s]
Extracting ./data\MNIST\raw\train-images-idx3-ubyte.gz to ./data\MNIST\raw
 
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data\MNIST\raw\train-labels-idx1-ubyte.gz
100%|██████████| 28881/28881 [00:01<00:00, 20237.61it/s]
Extracting ./data\MNIST\raw\train-labels-idx1-ubyte.gz to ./data\MNIST\raw
 
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data\MNIST\raw\t10k-images-idx3-ubyte.gz
100%|██████████| 1648877/1648877 [00:05<00:00, 299618.21it/s]
Extracting ./data\MNIST\raw\t10k-images-idx3-ubyte.gz to ./data\MNIST\raw
 
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data\MNIST\raw\t10k-labels-idx1-ubyte.gz
100%|██████████| 4542/4542 [00:00<?, ?it/s]
Extracting ./data\MNIST\raw\t10k-labels-idx1-ubyte.gz to ./data\MNIST\raw
 
train_data: torch.Size([60000, 28, 28])

3.7 构建神经网络与训练

import torchvision  # 数据集  放在辅助模块
import torch.utils.data as data  # 加载数据集放在主模块
import torch
import torch.nn as nn
#nn.Module所有神经网络的基类，需要用到它的前向、
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # self.fc1 = nn.Linear(28*28,512)
        # self.relu = nn.ReLU()
        self.layers = nn.Sequential(
            nn.Linear(28*28,512),
            nn.ReLU(),
            nn.Linear(512,256),
            nn.ReLU(),
            nn.Linear(256,128),
            nn.ReLU(),
            nn.Linear(128,10),
            nn.Softmax()
        )
    def forward(self, x):
        output = self.layers(x)
        return output
#*********///训练网络
#1实例化网络
net=Net()
#2优化器  单独梯度更新  优化的是网络参数
optimizer=torch.optim.Adam(net.parameters())
#3损失函数  MSE均方差损失   交叉熵损失CrossEntropyLoss
#nn.MSELoss()不能直接用
# loss_func = nn.CrossEntropyLoss()
loss_func=nn.MSELoss()
 
#4取数据  枚举
for i in range(1000):  # 训练多少轮
    for j, (x, y) in enumerate(train):
        x=x.view(-1,28*28)#就相当于reshape，做形状变换的
        output=net(x)# 拿到结果
        y=torch.zeros(y.size(0),10).scatter_(1,y.view(-1,1),1)
        loss=loss_func(output,y)#做损失
        #*****梯度更新3步
        #清空上一次梯度
        optimizer.zero_grad()
        #计算梯度
        loss.backward()
        #更新梯度
        optimizer.step()
        if j%100==0:
            print('Epoch:',loss.item())
            print(torch.argmax(output,dim=1))

3.8常用包

torch

torch.nn