笔记 | PyTorch安装及入门教程-轻识

点击上方“小白学视觉”，选择加"星标"或“置顶”

重磅干货，第一时间送达

本文内容概述如何安装PyTorch以及PyTorch的一些简单操作

本期笔记目录：

2.1 为何选择PyTorch?

PyTorch主要由4个包组成：

torch:可以将张量转换为torch.cuda.TensorFloat
torch.autograd:自动梯度
torch.nn：具有共享层和损失函数的神经网络库
torch.optim：具有通用的优化算法包（SGD、Adam）
2.2 安装Anaconda

Anaconda官网地址

https://www.anaconda.com/products/individual

这里选择All Users，一步一步操作即可

安装成功与否

2.3 安装Pytorch

由于pytorch有不同的版本，为了方便使用不同的版本，我们新建不同的环境（类比建造房屋，一个房屋放一个版本的pytorch），用来安装现有版本的pytorch

conda create –n pytorch python=3.7

选择Y

conda info –envs

conda activate pytorch

安装Pytorch

Pytorch的官方网站：

https://pytorch.org/

conda install pytorch torchvision cudatoolkit=10.2 -c pytorch

选择y

2.4 Numpy 与 Tensor

Numpy会把ndarray 放在CPU中运行加速，而由Torch产生的Tensor会放在GPU中进行加速运算

2.4.1 Tensor概述

从接口的角度划分：

1. torch.function           torch.sum       torch.add
2. tensor.function         tensor.view     tensor.add

从修改方式的角度划分：

1. 不修改自身数据，x.add(y)，x数据不变，返回新的Tensor
2. 修改自身数据，x.add_(y)，运算结果存在x中，x被修改

import torch
x=torch.tensor([1,2])
y=torch.tensor([3,4])
z=x.add(y)
print(z)
print(x)
x.add_(y)
print(x)

2.4.2 创建Tensor

创建Tensor的常用方法

* Tensor(*size)                          从参数构建，List或者Numpy都行
* eye(row,column)                    指定行数和列数的二维Tensor
* linspace(start,end,steps)        均匀分成
* longspace(start,end,steps)      10^start到10^end，均匀分成
* rand/randn(*size)                     生成[0,1)均与分布，标准正态分布
* ones(*size)                              返回指定shape张量，元素为1
* zeros(*size)                             返回指定shape张量，元素为0
* ones_like(t)
* zeros_like(t)
* arange(start,end,stop)
* from_Numpy(ndarray)

import torch

print(torch.Tensor([1,2,3,4,5,6]))
print(torch.Tensor(2,3))
t = torch.Tensor([[1,2,3],[4,5,6]])
print(t)
print(t.size())
t.shape
torch.Tensor(t.size())

torch.Tensor与torch.tensor的区别：

torch.Tensor是torch.empty 和 torch.tensor 之间的混合。传入数据时，torch.Tensor使用全局默认dtype(FloatTensor)，而torch.tensor是从数据中推断数据类型

torch.tensor(1)返回的是固定值1；torch.Tensor返回的是大小为1的张量

import torch
t1=torch.Tensor(1)
t2=torch.tensor(1)
print("t1的值{}，t1的数据类型{}".format(t1,t1.type()))
print("t2的值{}，t2的数据类型{}".format(t2,t2.type()))
# 输出
t1的值tensor([0.])，t1的数据类型torch.FloatTensor
t2的值1，t2的数据类型torch.LongTensor

import torch
print(torch.eye(2,2))
print(torch.zeros(2,3))
print(torch.linspace(1,10,4))
print(torch.rand(2,3))
print(torch.randn(2,3))
print(torch.zeros_like(torch.rand(2,3)))
#输出结果
tensor([[1., 0.],
     [0., 1.]])
tensor([[0., 0., 0.],
     [0., 0., 0.]])
tensor([ 1.,  4.,  7., 10.])
tensor([[0.5942, 0.1468, 0.3175],
     [0.2744, 0.9218, 0.7266]])
tensor([[ 1.0187, -0.2809,  1.0421],
     [-0.1697, -0.0604, -1.6645]])
tensor([[0., 0., 0.],
     [0., 0., 0.]])

2.4.3 修改Tensor形状

常用的tensor修改形状的函数

* size（）                         计算张量属性值，与shape等价
* numel(input)                  计算张量的元素个数
* view(*shape)                  修改张量的shape，共享内存，修改一个同时修改。
* resize()                           类似于view
* item                                返回标量
* unsqueeze                     在指定维度增加一个1
* squeeze                         在指定维度压缩一个1

import torch

x = torch.randn(2,3)

print(x.size())

print("维度：" ,x.dim())

print("这里把矩阵变为3x2的矩阵：",x.view(3,2))

print("这里把x展为1维向量：", x.view(-1))

y=x.view(-1)
z=torch.unsqueeze(y,0)
print("没增加维度前：",y,"  的维度",y.size())
print("增加一个维度:", z)
print("z的维度：", z.size())
print("z的个数：", z.numel())
# 输出结果
torch.Size([2, 3])
维度：2
这里把矩阵变为3x2的矩阵：tensor([[ 1.3014,  1.0249],
        [ 0.8903, -0.4908],
        [-0.3393,  0.7987]])
这里把x展为1维向量：tensor([ 1.3014,  1.0249,  0.8903, -0.4908, -0.3393,  0.7987])
没增加维度前：tensor([ 1.3014,  1.0249,  0.8903, -0.4908, -0.3393,  0.7987])   的维度 torch.Size([6])
增加一个维度: tensor([[ 1.3014,  1.0249,  0.8903, -0.4908, -0.3393,  0.7987]])
z的维度：torch.Size([1, 6])
z的个数：6

torch.view 与 torch.reshape 的异同

reshape()可以由torch.reshape()或者torch.Tensor.reshape()调用；而view()只可以由torch.Tensor.view()调用
新的size必须与原来的size与stride兼容，否则，在view之前必须调用contiguous()方法
同样返回数据量相同的但形状不同的Tensor，若满足view条件，则不会copy，若不满足，就copy
只想重塑，就使用torch.reshape，如果考虑内存并共享，就用torch.view
2.4.4 索引操作

常用选择操作的函数

* index_select(input,dim,index)   在指定维度上选择列或者行
* nonzero(input)                          获取非0元素的下标
* masked_select(input,mask)     使用二元值进行选择
* gather(input,dim,index)        指定维度选择数据，输出形状与index一致
* scatter_(input,dim,index,src)    gather的反操作，根据指定索引补充数据

import torch# 设置一个随机种子torch.manual_seed(100)# print(torch.manual_seed(100))x = torch.randn(2,3)
print(x)# 索引获取第一行所有数据x[0,:]
print(x[0,:])# 获取最后一列的数据x[:,-1]
print(x[:,-1])# 生成是否大于0的张量mask=x>0print(mask)# 获取大于0的值torch.masked_select(x,mask)
print(torch.masked_select(x,mask))# 获取非0下标，即行、列的索引torch.nonzero(mask)
print(torch.nonzero(mask))# 获取指定索引对应的值，输出根据以下规则得到# out[i][j] = input[index[i][j][j]]  # 如果 if dim == 0# out[i][j] = input[i][index[i][j]]  # 如果 if dim == 1index = torch.LongTensor([[0,1,1]])
print(index)
torch.gather(x,0,index)
index=torch.LongTensor([[0,1,1],[1,1,1]])
a = torch.gather(x,1,index)
print("a: ",a)# 把a的值返回到2x3的0矩阵中z = torch.zeros(2,3)
z.scatter_(1,index,a)# 输出结果tensor([[ 0.3607, -0.2859, -0.3938],
        [ 0.2429, -1.3833, -2.3134]])
tensor([ 0.3607, -0.2859, -0.3938])
tensor([-0.3938, -2.3134])
tensor([[ True, False, False],
        [ True, False, False]])
tensor([0.3607, 0.2429])
tensor([[0, 0],
        [1, 0]])
tensor([[0, 1, 1]])
a:  tensor([[ 0.3607, -0.2859, -0.2859],
        [-1.3833, -1.3833, -1.3833]])
Out[25]:
tensor([[ 0.3607, -0.2859,  0.0000],
        [ 0.0000, -1.3833,  0.0000]])

2.4.5 广播机制

import torch
import numpy as np
A = np.arange(0,40,10).reshape(4,1)
B = np.arange(0,3)
A1 = torch.from_numpy(A)   #形状4x1
B1 = torch.from_numpy(B)   #形状3
#自动广播
C=A1+B1
#也可以根据广播机制手动配置
# B1要与A1看齐，变成（1,3）
B2=B1.unsqueeze(0)
A2=A1.expand(4,3)
B3=B2.expand(4,3)
C1=A2+B3
print("A1:",A1)
print("B1:",B1)
print("C:",C)
print("B2:",B2)
print("A2:",A2)
print("B3:",B3)
print("C1:",C1)
# 输出结果
A1: tensor([[ 0],
        [10],
        [20],
        [30]], dtype=torch.int32)
B1: tensor([0, 1, 2], dtype=torch.int32)
C: tensor([[ 0,  1,  2],
        [10, 11, 12],
        [20, 21, 22],
        [30, 31, 32]], dtype=torch.int32)
B2: tensor([[0, 1, 2]], dtype=torch.int32)
A2: tensor([[ 0,  0,  0],
        [10, 10, 10],
        [20, 20, 20],
        [30, 30, 30]], dtype=torch.int32)
B3: tensor([[0, 1, 2],
        [0, 1, 2],
        [0, 1, 2],
        [0, 1, 2]], dtype=torch.int32)
C1: tensor([[ 0,  1,  2],
        [10, 11, 12],
        [20, 21, 22],
        [30, 31, 32]], dtype=torch.int32)

2.4.6 逐元素操作

常见的逐元素操作

* abs   add                                     绝对值，加法
* addcdiv(t,v,t1,t2)                        t1与t2按元素除后，乘v加t
* addcmul(t,v,t1,t2)                       t1与t2按元素乘后，乘v加t
* ceil   floor                                  向上取整；向下取整
* clamp(t, min , max)                    将张量元素限制在指定区间
* exp   log   pow                            指数，对数，幂
* mul(  或  *  )   neg                       逐元素乘法，取反
* sigmoid   tanh    softmax            激活函数
* sign   sqrt                                   取符号，开根号

import torch
t = torch.randn(1,3)
t1 = torch.randn(3,1)
t2 = torch.randn(1,3)
# t+0.1*(t1/t2)
a = torch.addcdiv(t, 0.1, t1, t2)
#计算sigmoid
b = torch.sigmoid(t)
# 将t限制在【0,1】之间
c = torch.clamp(t,0,1)
#t+2进行直接运算
t.add_(2)
print("t: ",t)
print("t1: ",t1)
print("t2: ",t2)
print("a: ",a)
print("b: ",b)
print("c: ",c)
# 结果
t:  tensor([[1.7266, 2.0815, 3.4672]])
t1:  tensor([[0.2309],
        [0.3393],
        [1.3639]])
t2:  tensor([[-0.5414, -1.4628, -0.4191]])
a:  tensor([[-0.3161,  0.0657,  1.4121],
        [-0.3361,  0.0583,  1.3863],
        [-0.5254, -0.0117,  1.1418]])
b:  tensor([[0.4321, 0.5204, 0.8126]])
c:  tensor([[0.0000, 0.0815, 1.0000]])

2.4.7 归并操作

常用的归并操作

* cumprod(t,axis)        在指定维度上对t进行累积
* cumsum                    对指定维度进行累加
* dist（a,b,p=2）         返回a,b之间的p阶范数
* mean   ;  median       平均值，中位数
* std   var                    标准差       方差
* norm(t,p=2)               返回t的p阶范数
* prod(t)   sum(t)           返回所有元素的积，和

import torch
a=torch.linspace(0,10,6)
#使用view变为2x3矩阵
a=a.view((2,3))
print("a: ",a)
# 沿着y轴方向累加，dim=0
b=a.sum(dim=0)
print("b: ",b)
# 沿着y轴方向累加，dim=0,并保留含1的维度
b=a.sum(dim=0,keepdim=True)
print("b: ",b)
# 结果
a:  tensor([[ 0.,  2.,  4.],
        [ 6.,  8., 10.]])
b:  tensor([ 6., 10., 14.])
b:  tensor([[ 6., 10., 14.]])

2.4.8 比较操作

常用的比较函数

* eq                                    是否相等
* equal                               是否相同的shape和值
* ge  /  le  /  gt  /  lt             大于、小于、大于等于、小于等于
* max  /  min  (t,axis)         返回最值，指定axis返回下标
* topk(t,k,axis)                   在指定维度上取最高的k个值

import torch
x=torch.linspace(0,10,6).view(2,3)
print(torch.max(x))
print(torch.max(x,dim=0))
print(torch.topk(x,1,dim=0))
# 结果
tensor([[ 0.,  2.,  4.],
        [ 6.,  8., 10.]])
tensor(10.)
torch.return_types.max(
values=tensor([ 6.,  8., 10.]),
indices=tensor([1, 1, 1]))
torch.return_types.topk(
values=tensor([[ 6.,  8., 10.]]),
indices=tensor([[1, 1, 1]]))

2.4.9 矩阵操作

常用的矩阵函数

* dot(t1,t2)                                                       计算内积
* mm(mat1,mat2)    bmm(batch1,batch2)       计算矩阵乘积，3D矩阵
* mv(t1,v1)                                                      计算矩阵与向量乘法
* t                                                                    转置
* svd(t)                                                             计算SVD

import torch
a=torch.tensor([2,3])
b=torch.tensor([3,4])
print(torch.dot(a,b))
x=torch.randint(10,(2,3))
print(x)
y=torch.randint(6,(3,4))
print(y)
print(torch.mm(x,y))
x=torch.randint(10,(2,2,3))
print(x)
y=torch.randint(6,(2,3,4))
print(y)
print(torch.bmm(x,y))
#结果
tensor(18)
tensor([[1, 1, 1],
        [3, 1, 9]])
tensor([[1, 4, 4, 5],
        [1, 5, 2, 4],
        [2, 0, 3, 3]])
tensor([[ 4,  9,  9, 12],
        [22, 17, 41, 46]])
tensor([[[0, 9, 3],
         [7, 1, 4]],
        [[9, 6, 3],
         [2, 0, 1]]])
tensor([[[0, 5, 1, 3],
         [2, 4, 3, 1],
         [5, 2, 1, 1]],
        [[4, 3, 0, 0],
         [4, 5, 0, 4],
         [0, 0, 3, 3]]])
tensor([[[33, 42, 30, 12],
         [22, 47, 14, 26]],
        [[60, 57,  9, 33],
         [ 8,  6,  3,  3]]])

2.4.10 PyTorch与Numpy比较

PyTorch与Numpy函数对照表

	np.ndarry([3.2,4.3],dtype=np.float16)	torch.tensor([3.2,4.3], dtype=torch.float16
	x.copy()	x.clone()
	np.dot	torch.mm
	x.ndim	x.dim
	x.size	x.nelement()
	x.reshape	x.reshape,x.view
	x.flatten	x.view(-1)
	np.floor(x)	torch.floor(x), x.floor()
	np.less	x.lt
	np.random.seed	torch.manual_seed

2.5 Tensor与Autograd

2.5.1 自动求导的要点

创建叶子节点的Tensor，使用requires_grad指定是否需要对其进行操作
可以利用requiresgrad()方法修改Tensor的requires_grad属性。可以调用 .detach()或者 with torch.no_grad()
自动赋予grad_fn属性，表示梯度函数。
执行backward()函数后，保存到grad属性中了。计算完成，非叶子节点梯度会自动释放
backward()函数接收参数，维度相同。
反向传播的中间缓存会被清空，如果需要多次反向传播，需指定backward中的retain_graph=True 多次反向传播时，梯度累加
非叶子节点的梯度backward 调用后即被清空
用 torch.no_grad()包裹代码块形式阻止autograd去追踪那些标记为.requesgrad=True的张量历史记录
2.5.2 计算图

表达式z=wx+b

可以写成：y=wx z=y+b

x,w,b为变量；y,z是计算得到的变量，不是叶子节点

根据链式法则计算的

z对x求导为w
z对w求导为x
z对b求导为1
2.5.3 标量反向传播

主要步骤如下：

定义叶子节点及算子节点
查看叶子节点、非叶子节点的其他属性
自动求导，实现梯度方向传播，也就是梯度的反向传播

分步进行展示

（1）定义叶子节点及算子节点

import torch
# 定义输入张量x
x=torch.Tensor([2])
# 初始化权重参数w,偏移量b，并设置require_grad属性为True
w=torch.randn(1,requires_grad=True)
b=torch.randn(1,requires_grad=True)
# 实现前向传播
y=torch.mul(w,x)   # 等价于w*x
z=torch.add(y,b)   # 等价于y+b
# 查看x,w,b叶子节点的requires_grad属性
print("x,w,b叶子节点的requires_grad属性分别为：{}，{}，{}".format(x.requires_grad,w.requires_grad,b.requires_grad))

运行结果：

x,w,b叶子节点的requires_grad属性分别为：False，True，True

（2）查看叶子节点、非叶子节点的其他属性

# 查看非叶子节点的requires_grad属性
print("y, z的requires_grad属性分别为：{}，{}".format(y.requires_grad,z.requires_grad))
# 查看各节点是否为叶子节点
print("x, w, b, y, z是否为叶子节点：{}，{}，{}，{}，{}".format(x.is_leaf,w.is_leaf,b.is_leaf,y.is_leaf,z.is_leaf))
# 查看叶子节点的grad_fn属性
print("x, w, b的 grad_fn属性：{}，{}，{}".format(x.grad_fn,w.grad_fn,b.grad_fn))
# 查看非叶子节点的grad_fn属性
print("y, z是否为叶子节点：{}，{}".format(y.grad_fn,z.grad_fn))

运行结果：

y, z的requires_grad属性分别为：True，True
x, w, b, y, z是否为叶子节点：True，True，True，False，False
x, w, b的 grad_fn属性：None，None，None
y, z是否为叶子节点：<MulBackward0 object at 0x00000295C920E948>，<AddBackward0 object at 0x00000295C920EA48>

（3）自动求导，实现梯度方向传播，也就是梯度的反向传播

# 基于张量z进行求导，执行backward后计算图会自动清空
z.backward()
# 如果需要多次使用backward，需要修改参数为retain_graph=True，此时梯度累加
# z.backward(retain_graph=True)
# 查看叶子节点的梯度，x是叶子节点但是无需求导，故梯度为None
print("参数w, b，x的梯度分别为：{},{},{}".format(w.grad,b.grad,x.grad))
# 非叶子节点的梯度，执行backward后会自动清空
print("非叶子节点y, z的梯度分别为：{},{}".format(y.grad,z.grad))

运行结果：

参数w, b，x的梯度分别为：tensor([2.]),tensor([1.]),None
非叶子节点y, z的梯度分别为：None,None

2.5.4 非标量的反向传播

张量对张量的求导转换成标量对张量的求导

backward函数的格式

backward(gradient=None, retain_graph=None, create_graph=False)

举例：

# (1)定义叶子节点及计算节点
import torch
# 定义叶子节点张量x，形状为1x2
x = torch.tensor([[2, 3]], dtype=torch.float, requires_grad=True)
# 初始化雅可比矩阵
J = torch.zeros(2,2)
# 初始化目标张量，形状1x2
y = torch.zeros(1,2)
# 定义y与x之间的映射关系
# y1=x1**2 + 3*x2, y2=x2**2 + 2*x1
y[0, 0] = x[0, 0]**2+3*x[0, 1]
y[0, 1] = x[0, 1]**2+2*x[0, 0]
# 首先让v=(1,0)得到y1对x的梯度
# 然后让v=(0,1)得到y2对x的梯度
# 需要重复使用backward(),所以设置参数retain_graph=True
# 生成y1对x的梯度
y.backward(torch.Tensor([[1,0]]),retain_graph=True)
J[0]=x.grad
# 梯度是累加的，所以需要对x的梯度清零
x.grad = torch.zeros_like(x.grad)
# 生成y2对x的梯度
y.backward(torch.Tensor([[0,1]]))
J[1]=x.grad
# 显示雅克比矩阵的值
print(J)

运行结果：

tensor([[4., 3.],
        [2., 6.]])

2.6 使用Numpy实现机器学习

给出一个数组x，基于表达式y=3x^2+2，加上一些噪声数据到达另一组数据y

构建一个机器学学模型，学习y=wx^2+b中的2个参数，w和b，利用x，y数据为训练数据

## （1）导入所需要的库
# -*- coding : utf-8 -*-
import numpy as np
%matplotlib inline
from matplotlib import pyplot as plt
## （2）生成随机数据x及目标y
# 设置随机种子，生成同一份数据，方便多种方法比较
np.random.seed(100)
x = np.linspace(-1,1,100).reshape(100,1)
y = 3*np.power(x,2) + 2 + 0.2*np.random.rand(x.size).reshape(100,1)
## (3)查看x,y数据分布情况
plt.scatter(x,y)
plt.show()
## (4)初始化权重参数
w1 = np.random.rand(1,1)
b1 = np.random.rand(1,1)
## （5）训练模型
lr =0.001  # 学习率
for i in range(800):
    # 前向传播
    y_pred = np.power(x,2)*w1+b1
    # 定义损失函数
    loss = 0.5 * (y_pred - y) **2
    loss = loss.sum
    # 计算梯度
    grad_w = np.sum((y_pred - y)*np.power(x,2))
    grad_b = np.sum(y_pred - y)
    # 使用梯度下降法，使得loss最小
    w1 -= lr * grad_w
    b1 -= lr * grad_b
## 可视化结果
plt.plot(x, y_pred, 'r-', label='predict')
plt.scatter(x,y,color='blue',marker='o',label='true')
plt.xlim(-1,1)
plt.ylim(2,6)
plt.legend()
plt.show()
print(w1,b1)

2.7 使用Tensor及Autograd实现机器学习

# （1） 导入所需要的库
import torch as t
%matplotlib inline
from matplotlib import pyplot as plt
# (2)生成训练数据，并可视化数据分布情况
t.manual_seed(100)
dtype=t.float
# 生成x坐标数据，x为tensor，需要把x的形状转换为100x1
x = t.unsqueeze(t.linspace(-1,1,100),dim=1)
# 生成y坐标数据，y为tensor，形状为100x1，加上一些噪声
y = 3*x.pow(2)+ 2 + 0.2*t.rand(x.size())

# 画图，将tensor数据转换为numpy数据
plt.scatter(x.numpy(),y.numpy())
plt.show()
# (3)初始化权重
# 随机初始化参数，w,b需要学习，所以设定requires_grad=True
w = t.randn(1,1,dtype=dtype,requires_grad=True)
b = t.zeros(1,1,dtype=dtype,requires_grad=True)
# (4)训练模型
lr = 0.001 # 学习率
for ii in range(800):
    # 前向传播，定义损失函数
    y_pred = x.pow(2).mm(w) + b
    loss = 0.5 * (y_pred - y) **2
    loss = loss.sum()

    # 自动计算梯度
    loss.backward()

    # 手动更新参数，使用torch.no_grad(),使上下文切断自动求导计算
    with t.no_grad():
        w -= lr * w.grad
        b -= lr * b.grad

    # 梯度清零
        w.grad.zero_()
        b.grad.zero_()

# (5)可视化训练结果
plt.plot(x.numpy(), y_pred.detach().numpy(), 'r-', label='predict')
plt.scatter(x.numpy(),y.numpy(),color='blue',marker='o',label='true')
plt.xlim(-1,1)
plt.ylim(2,6)
plt.legend()
plt.show()
print(w,b)

下载1：OpenCV-Contrib扩展模块中文版教程

在「小白学视觉」公众号后台回复：扩展模块中文教程，即可下载全网第一份OpenCV扩展模块教程中文版，涵盖扩展模块安装、SFM算法、立体视觉、目标跟踪、生物视觉、超分辨率处理等二十多章内容。

下载2：Python视觉实战项目52讲

在「小白学视觉」公众号后台回复：Python视觉实战项目，即可下载包括图像分割、口罩检测、车道线检测、车辆计数、添加眼线、车牌识别、字符识别、情绪检测、文本内容提取、面部识别等31个视觉实战项目，助力快速学校计算机视觉。

下载3：OpenCV实战项目20讲

在「小白学视觉」公众号后台回复：OpenCV实战项目20讲，即可下载含有20个基于OpenCV实现20个实战项目，实现OpenCV学习进阶。

交流群

欢迎加入公众号读者群一起和同行交流，目前有SLAM、三维视觉、传感器、自动驾驶、计算摄影、检测、分割、识别、医学影像、GAN、算法竞赛等微信群（以后会逐渐细分），请扫描下面微信号加群，备注：”昵称+学校/公司+研究方向“，例如：”张三 + 上海交大 + 视觉SLAM“。请按照格式备注，否则不予通过。添加成功后会根据研究方向邀请进入相关微信群。请勿在群内发送广告，否则会请出群，谢谢理解~

笔记 | PyTorch安装及入门教程

本文内容概述如何安装PyTorch以及PyTorch的一些简单操作

2.1 为何选择PyTorch?

2.2 安装Anaconda

2.3 安装Pytorch

2.4 Numpy 与 Tensor

2.4.1 Tensor概述

2.4.2 创建Tensor

2.4.3 修改Tensor形状

2.4.4 索引操作

2.4.5 广播机制

2.4.6 逐元素操作

2.4.7 归并操作

2.4.8 比较操作

2.4.9 矩阵操作

2.4.10 PyTorch与Numpy比较

2.5 Tensor与Autograd

2.5.1 自动求导的要点

2.5.2 计算图

2.5.3 标量反向传播

2.5.4 非标量的反向传播

2.6 使用Numpy实现机器学习

2.7 使用Tensor及Autograd实现机器学习