动手深度学习——Pytorch 入门语法一

持续更新ing

数据操作

import torchx = torch.arange(12) # 创建⼀个⾏向量x。这个⾏向量包含从0开始的前12个整数
print(x.shape)  # 通过张量的shape属性来访问张量（沿每个轴的⻓度）的形状。
print(x.numel())  # 检查它的⼤小（size）X = x.reshape(3,4)
print(X)
print(x.view(3,4))# 输出和上面一样。
# view()和reshape()功能一样，都可以改变张量形状。z = torch.zeros((2,3,4)) # 全零张量
print(z)z1 = torch.ones((2,3,4)) # 全1张量
print(z1)randomNumber = torch.randn(3,4) # 创建⼀个形状为（3,4）的张量。其中的每个元素都从均值为0、标准差为1的标准⾼斯分布（正态分布）中随机采样print(torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])) # 给张量直接赋值

import torchx= torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2,2,2,2])
print(x+y,x-y,x*y,x/y, x**y) # **运算符是求幂运算print(torch.exp(x)) # 计算e的幂X = torch.arange(12,dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0,1,4, 3],[1, 2, 3, 4], [4, 3, 2, 1]])torch.cat((X,Y),dim=0) # 竖直连接，增加行。
torch.cat((X,Y),dim=1) # 横向连接，增加列print(X == Y) # 结果为Ture 和 Falseprint(X.sum())  # 张量内元素求和
a = torch.arange(3).reshape((3,1))
b = torch.arange(2).reshape((1,2))print(a,b)
print(a + b) # 沿着数组中⻓度为1的轴进⾏⼴播，矩阵a将复制列，矩阵b将复制⾏，然后再按元素相加。print(X[-1],X[1:3]) # 索引和切片，与列表相似X[1,2] = 9 # 指定索引来将元素写⼊矩阵。
print(X)X[0:2,:] = 12 # 为多个元素赋值相同的值
print(X)A =X.numpy() # 将深度学习框架定义的张量转换为NumPy张量（ndarray）
B = torch.tensor(A)
print(type(A), type(B))a = torch.tensor([3.5])
print(a,a.item(), float(a), int(a)) #将⼤小为1的张量转换为Python标量A = torch.arange(20).reshape((5,4))print(A)
print(A.T) # 转置A = torch.arange(20,dtype=torch.float32).reshape(5,4)
B = A.clone() # 通过分配新内存，将A的⼀个副本分配给B
print(A,A+B)

Tensor的合并与拆分

对于需要拼接的张量，维度数量必须相同，进行拼接的维度的尺寸可以不同，但是其它维度的尺寸必须相同。

>>> import torch
>>> x = torch.randn(2, 3)
>>> x
tensor([[-0.1997, -0.6900,  0.7039],[ 0.0268, -1.0140, -2.9764]])
>>> torch.cat((x, x, x), 0)    # 在 0 维(纵向)进行拼接，可以将一个张量序列进行合并。
tensor([[-0.1997, -0.6900,  0.7039],[ 0.0268, -1.0140, -2.9764],[-0.1997, -0.6900,  0.7039],[ 0.0268, -1.0140, -2.9764],[-0.1997, -0.6900,  0.7039],[ 0.0268, -1.0140, -2.9764]])
>>> torch.cat((x, x, x), 1)    # 在 1 维(横向)进行拼接
tensor([[-0.1997, -0.6900,  0.7039, -0.1997, -0.6900,  0.7039, -0.1997, -0.6900,0.7039],[ 0.0268, -1.0140, -2.9764,  0.0268, -1.0140, -2.9764,  0.0268, -1.0140,-2.9764]])
>>> y1 = torch.randn(5, 3, 6)
>>> y2 = torch.randn(5, 3, 6)
>>> torch.cat([y1, y2], 2).size()
torch.Size([5, 3, 12])
>>> torch.cat([y1, y2], 1).size()
torch.Size([5, 6, 6])

沿着一个新维度对输入张量序列进行连接。序列中所有的张量都应该为相同形状

>>> x1 = torch.randn(2, 3)
>>> x2 = torch.randn(2, 3)
>>> torch.stack((x1, x2), 0).size()    # 在 0 维插入一个维度，进行区分拼接。也可以对一个张量序列进行拼接，即将多个相同维度的张量合并到一个高维度的张量中。
torch.Size([2, 2, 3])
>>> torch.stack((x1, x2), 1).size()    # 在 1 维插入一个维度，进行组合拼接
torch.Size([2, 2, 3])
>>> torch.stack((x1, x2), 2).size()
torch.Size([2, 3, 2])
>>> torch.stack((x1, x2), 0)
tensor([[[-0.3499, -0.6124,  1.4332],[ 0.1516, -1.5439, -0.1758]],[[-0.4678, -1.1430, -0.5279],[-0.4917, -0.6504,  2.2512]]])
>>> torch.stack((x1, x2), 1)
tensor([[[-0.3499, -0.6124,  1.4332],[-0.4678, -1.1430, -0.5279]],[[ 0.1516, -1.5439, -0.1758],[-0.4917, -0.6504,  2.2512]]])
>>> torch.stack((x1, x2), 2)
tensor([[[-0.3499, -0.4678],[-0.6124, -1.1430],[ 1.4332, -0.5279]],[[ 0.1516, -0.4917],[-1.5439, -0.6504],[-0.1758,  2.2512]]])

数据预处理

import torchA = torch.arange(20,dtype=torch.float32).reshape(5,4)
B = A.clone() # 通过分配新内存，将A的⼀个副本分配给B
print(A,'\n',A+B)print(A*B) # 两个矩阵的按元素乘法称为Hadamard积# 将张量乘以或加上⼀个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘。
a = 2
X = torch.arange(24).reshape(2,3,4)
print(a+X,'\n', (a*X).shape)x= torch.arange(4,dtype=torch.float32)
print(x,'\n',x.sum())'''为了通过求和所有⾏的元素来降维（轴0），我们可以在调⽤函数时指定axis=0。
由于输⼊矩阵沿0轴降维以⽣成输出向量，因此输⼊轴0的维数在输出形状中消失。'''
A_sum_axis0=A.sum(axis=0)
print(A_sum_axis0)
print(A_sum_axis0.shape)# 指定axis=1将通过汇总所有列的元素降维（轴1）。因此，输⼊轴1的维数在输出形状中消失。
A_sum_axis1=A.sum(axis=1)
print(A_sum_axis1)
print(A_sum_axis1.shape)# 沿着⾏和列对矩阵求和，等价于对矩阵的所有元素进⾏求和。
print(A.sum(axis=[0,1]))
print(A.sum()) # 和上面一句等价，所有元素求和# 平均值
print(A.mean(),A.sum()/A.numel())# 计算平均值的函数也可以沿指定轴降低张量的维度。
print(A.mean(axis=0),A.sum(axis=0)/A.shape[0])# 计算总和或均值时保持轴数不变
sum_A = A.sum(axis=1,keepdims=True)
print(sum_A)# 由于sum_A在对每⾏进⾏求和后仍保持两个轴，我们可以通过⼴播将A除以sum_A。
print(A/sum_A)'''如果我们想沿某个轴计算A元素的累积总和，⽐如axis=0（按⾏计算），我们可以调⽤cumsum函数。此函数
不会沿任何轴降低输⼊张量的维度'''
print(A.cumsum(axis=0))# 点积
y = torch.ones(4,dtype=torch.float32)
print(x)
print(y)
print(torch.dot(x,y))'''在代码中使⽤张量表⽰矩阵-向量积，我们使⽤与点积相同的mv函数.
注意，A的列维数（沿轴1的⻓度）必须与x的维数（其⻓度）相同。'''
print('矩阵向量积')
print(A.shape)
print(x.shape)
print(torch.mv(A,x))'''将矩阵-矩阵乘法AB看作是简单地执⾏m次矩阵-向量积，并将结果拼接在⼀起，形成⼀个n*m矩阵。'''
B = torch.ones(4,3)
print(torch.mm(A,B))# 范数
u = torch.tensor([3.0, -4.0])
print(torch.norm(u)) #这里使用的范数默认是第二范数L2print(torch.abs(u).sum()) # 计算第一范数L1# Frobenius范数（Frobenius norm）是矩阵元素平⽅和的平⽅根,它就像是矩阵形向量的L2范数
print(torch.norm(torch.ones((4,9))))

torch.matmul(a,b)——高维矩阵乘积

import torcha = torch.ones(3,4)
print("a:",a)
b = torch.ones(4,2)
print("b:", b)print(torch.matmul(a, b))

运行截图

维数相同的高维张量相乘
要求第一维度相同，后两个维度能满足矩阵相乘条件。
A.shape =（b,m,n)；B.shape = (b,n,k)
numpy.matmul(A,B) 结果shape为(b,m,k)

import torcha = torch.ones(3,1,2)
print(a)
b = torch.ones(3,2,2)
print(b)print(torch.matmul(a, b))

运行截图

维数不同的高维张量相乘
比如 A.shape =（m,n)； B.shape = (b,n,k)； C.shape=(k,l)
numpy.matmul(A,B) 结果shape为(b,m,k)
numpy.matmul(B,C) 结果shape为(b,n,l)
2D张量要和3D张量的后两个维度满足矩阵相乘条件。

import torcha = torch.ones(1, 2)
print("a:",a)
b = torch.ones(2, 2, 3)
print("b:",b)
c = torch.ones(3, 1)
print("c:",c)print("a*b:",torch.matmul(a, b))
print("b*c:",torch.matmul(b, c))

运行截图

微积分

import torchimport numpy as np
from IPython import display
from d2l import torch as d2ldef f(x):return 3*x**2-4*xdef numerical_lim(f,x,h):return (f(x+h)-f(x))/hh=0.1
for i in range(5):print(f'h={h:.5f},numerical_lim={numerical_lim(f,1,h):.5f}')h *= 0.1def use_svg_display(): #@sava'''使用svg格式显示绘图'''display.set_matplotlib_formats('svg')def set_figsize(figsize=(3.5,2.5)): #@save'''设置matplotlib的图表大小'''use_svg_display()d2l.plt.rcParams['figure.figsize'] = figsizedef set_axes(axes,xlabel, ylabel,xlim, ylim, xscale, yscale, legend):'''设置matplotlib的轴'''axes.set_xlabel(xlabel)axes.set_ylabel(ylabel)axes.set_xscale(xscale)axes.set_yscale(yscale)axes.set_xlim(xlim)axes.set_ylim(ylim)if legend:axes.legend(legend)axes.grid()def plot(X,Y=None, xlabel=None,ylabel=None, legend=None, xlim=None,ylim=None,xscale='linear',yscale='linear',fmts=('-','m--', 'g-', 'r:'),figsize=(3.5, 2.5),axes=None):'''绘制数据点'''if legend is None:legend = []set_figsize(figsize)axes = axes if axes else d2l.plt.gca()#如果'X'有一个轴，输出Truedef has_one_axis(X):return (hasattr(X, 'ndim') and X.ndim == 1 or isinstance(X, list) and nothasattr(X[0], '__len__'))if has_one_axis(X):X=[X]if Y is None:X,Y = [[]]*len(X),Xelif has_one_axis(Y):Y = [Y]if len(X) != len(Y):X = X*len(Y)axes.cla()for x, y, fmt in zip(X, Y, fmts):if len(x):axes.plot(x,y, fmt)else:axes.plot(y,fmt)set_axes(axes,xlabel,ylabel,xlim, ylim,xscale,yscale,legend)d2l.plt.show()x = np.arange(0,3,0.1)
plot(x,[f(x), 2*x-3], 'x', 'f(x)', legend=['f(x)', 'Tangent line (x=1)'])

自动微分

'''
python3.7
-*- coding: UTF-8 -*-
@Project -> File   ：Code -> __init__.py
@IDE    ：PyCharm
@Author ：YangShouWei
@USER: 296714435
@Date   ：2022/2/19 10:19:49
@LastEditor:
'''import torchx = torch.arange(4.0)
print("x:",x)x.requires_grad_(True) # 等价于x = torch.arange(4.0, requires_grad=True)
print("x.grad:",x.grad) # 默认值是Noney = 2*torch.dot(x,x)
print("y:",y)# 调⽤反向传播函数来⾃动计算y关于x每个分量的梯度.
y.backward() # 反向传播
x.grad
print("x.grad:",x.grad)x.grad.zero_()
y = x.sum()
y.backward()
print("x.grad:",x.grad)# 非标量变量的反向传播
#对⾮标量调⽤`backward`需要传⼊⼀个`gradient`参数，该参数指定微分函数关于`self`的梯度。
# 在我们的例⼦中，我们只想求偏导数的和，所以传递⼀个1的梯度是合适的
x.grad.zero_()
y = x*x# 等价于y.backward(torch.ones(len(x)))
y.sum().backward()
print("x.grad:",x.grad)x.grad.zero_() # 梯度置0
y = x*x
u = y.detach()
z = u*x
z.sum().backward()
print("x.grad==u:",x.grad==u)# 由于记录了y的计算结果，我们可以随后在y上调⽤反向传播，得到y=x*x关于的x的导数，即2*x。
x.grad.zero_()
y.sum().backward()
print("x.grad == 2*x:",x.grad == 2*x)# Python 控制流的梯度计算
def f(a):b = a*2while b.norm() < 1000:b=b*2if b.sum() > 0:c = belse:c = 100*breturn c# 计算梯度
a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()print("a.grad == d/a:",a.grad == d/a)

运行截图

概率

基本概率论

'''
python3.7
-*- coding: UTF-8 -*-
@Project -> File   ：Code -> probability
@IDE    ：PyCharm
@Author ：YangShouWei
@USER: 296714435
@Date   ：2022/2/19 14:46:22
@LastEditor:
'''import torch
from torch.distributions import multinomial
from d2l import torch as d2l# 为了抽取⼀个样本，即掷骰⼦，我们只需传⼊⼀个概率向量。
# 输出是另⼀个相同⻓度的向量：它在索引i处的值是采样结果中i出现的次数。fair_prob = torch.ones([6]) / 6 # 表示骰子的六个面被掷到的概率都是1/6
print(multinomial.Multinomial(1,fair_prob).sample()) # 相当于掷骰子一次，掷到哪个数字，对应位置就显示1，print(multinomial.Multinomial(10,fair_prob).sample()) # 相当于掷骰子10次，打印的结果是每个面被掷到的次数counts = multinomial.Multinomial(1000,fair_prob).sample()
print(counts/1000) # 相对频率作为估计值# 进行500组实验，每组抽取10个样本
counts = multinomial.Multinomial(10,fair_prob).sample((500,))
cum_counts = counts.cumsum(dim=0)
estimates = cum_counts / cum_counts.sum(dim=1, keepdims=True)d2l.set_figsize((6, 4.5))
for i in range(6):d2l.plt.plot(estimates[:, i].numpy(),label=("P(die="+str(i+1)+")"))
d2l.plt.axhline(y=0.167,color='black',linestyle='dashed')
d2l.plt.gca().set_xlabel("Groups of experiments")
d2l.plt.gca().set_ylabel("Estimated probability")
d2l.plt.legend();
d2l.plt.show()

运行截图

正太分布与平方损失

import math
import numpy as np
from d2l import torch as d2ldef normal(x, mu, sigma):"""计算正太分布"""p = 1/math.sqrt(2 * math.pi * sigma**2)return p*np.exp(-0.5/sigma**2 * (x-mu)**2)if __name__ == '__main__':#使用numpy进行可视化x = np.arange(-7, 7, 0.01)#均值和标准差对params = [(0, 1),(0, 2),(3,1)]d2l.plot(x, [normal(x, mu, sigma) for mu, sigma in params], xlabel='x',ylabel='p(x)', figsize=(5.5, 4.0),legend=[f'mean {mu}, std{sigma}'for mu, sigma in params])d2l.plt.show()

运行截图

生成数据集

from d2l import torch as d2l
import torchdef synthetix_data(w,b, num_examples):"""⽣成y = Xw + b + 噪声。""""""返回一个张量，包含从给定参数means,std的离散正态分布中抽取随机数。 均值means是一个张量，包含每个输出元素相关的正态分布的均值。std是一个张量，包含每个输出元素相关的正态分布的标准差。 均值和标准差的形状不须匹配，但每个张量的元素个数须相同。"""X = torch.normal(0, 1, (num_examples, len(w)))# print(X)y = torch.matmul(X, w) +b # 张量乘法# print(y)y += torch.normal(0, 0.01, y.shape)return X, y.reshape((-1, 1))true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetix_data(true_w, true_b, 1000)d2l.set_figsize()
d2l.plt.scatter(features[:,(1)].detach().numpy(), labels.detach().numpy(),1)
d2l.plt.show()

数据分布图

动手深度学习——Pytorch 入门语法一相关推荐

深度学习 — — PyTorch入门（二）
在深度学习--PyTorch入门(一)中我们介绍了构建网络模型和加载数据的内容,本篇将继续介绍如何完成对模型的训练. 训练:更新网络权重构建网络结构和加载完数据集之后,便可以开始进行网络权重的训练. ...
pytorch 矩阵相乘_深度学习 — — PyTorch入门（三）
点击关注我哦 autograd和动态计算图可以说是pytorch中非常核心的部分,我们在之前的文章中提到:autograd其实就是反向求偏导的过程,而在求偏导的过程中,链式求导法则和雅克比矩阵是其实现 ...
深度学习 — — PyTorch入门（三）
点击关注我哦 autograd和动态计算图可以说是pytorch中非常核心的部分,我们在之前的文章中提到:autograd其实就是反向求偏导的过程,而在求偏导的过程中,链式求导法则和雅克比矩阵是其实现 ...
动手深度学习PyTorch（九）GRU、LSTM、Bi-RNN
GRU 上一篇介绍了循环神经网络中的梯度计算方法.我们发现,当时间步数较大或者时间步较小时,循环神经网络的梯度较容易出现衰减或爆炸.虽然裁剪梯度可以应对梯度爆炸,但无法解决梯度衰减的问题.通常由于这个 ...
动手深度学习PyTorch（十二）word2vec
独热编码独热编码即 One-Hot 编码,又称一位有效编码,其方法是使用N位状态寄存器来对N个状态进行编码,每个状态都有它独立的寄存器位,并且在任意时候,其中只有一位有效.举个例子,假设我们有四个样 ...
动手学深度学习Pytorch Task01
深度学习目前以及未来都有良好的发展前景.正值疫情期间,报名参加了动手学深度学习pytorch版的公开课,希望在以后的学习生活中能够灵活运用学到的这些知识. 第一次课主要包含三个部分:线性回归.soft ...
【动手学深度学习PyTorch版】6 权重衰退
上一篇移步[动手学深度学习PyTorch版]5 模型选择 + 过拟合和欠拟合_水w的博客-CSDN博客目录一.权重衰退 1.1 权重衰退 weight decay:处理过拟合的最常见方法(L2_p ...
【动手学深度学习PyTorch版】27 数据增强
上一篇请移步[动手学深度学习PyTorch版]23 深度学习硬件CPU 和 GPU_水w的博客-CSDN博客目录一.数据增强 1.1 数据增强(主要是关于图像增强) ◼ CES上的真实的故事 ◼ ...
150页书籍《PyTorch 深度学习快速入门指南》附PDF电子版
为什么说是极简教程,首先本书只涵盖了150页.内容比较精简,特别适合作为 PyTorch 深度学习的入门书籍.为什么这么说呢?因为很多时候,一份厚重的书籍往往会削弱我们学习的积极性,在学习一门新的语言 ...

动手深度学习——Pytorch 入门语法一

持续更新ing

数据操作

Tensor的合并与拆分

数据预处理

torch.matmul(a,b)——高维矩阵乘积

微积分

自动微分

概率

基本概率论

正太分布与平方损失

生成数据集

动手深度学习——Pytorch 入门语法一相关推荐

最新文章

热门文章