零基础学习人工智能—Python—Pytorch学习（一）

前言

其实学习人工智能不难，就跟学习软件开发一样，只是会的人相对少，而一些会的人写文章，做视频又不好好讲。

比如，上来就跟你说要学习张量，或者告诉你张量是向量的多维度等等模式的讲解；目的都是让别人知道他会这个技术，但又不想让你学。

对于学习，多年的学习经验，和无数次的回顾学习过程，都证明了一件事，如果一篇文章，一个视频，一个课程，我没学明白，那问题一定不在我，而是上课的主动或被动的不想让我学会，所以，出问题的一定是学习资料。

比如英语，当真会了以后，再回去看自己之前学过的课，就知道了，那是英语老师没好好教，哪有真正想让你学会英语的人，会告诉你【come=来，out=出去】呀。

比如线性代数，等会了以后，再回去看之前看不懂的课程视频，就知道了，是上课老师估计模糊的关键信息。

学习软件开发，相信大家也都有类似的经验，当你想学一个知识点时，各种搜索，就是看不懂，最后学会的原因只有两种，1，你找到了真正的教你知识的文章，2，你通过搜索的信息，自己悟了出来。这其实就是在证明，绝大多数的文章和视频都不想真正教你，包括正规学校的老师和教材。

入门学习

首先，介绍一下我学习的资料，我通过一通搜索，终于找到了最好的学习资料，该视频是认真教你学习的，唯一的缺点可能就是，上课的人说的是英语，有点印度口音。不过，个人感觉他带点口语，反而更好听懂。

重点关注一下下面单词视频里会多次提到，注意了后就不会被英语卡住了。

numpy：这个单词，这不是个单词，但是是python的库。

vector：向量，下面有解释。

tensor：张量，下面有解释。

gradient：梯度，指的就是我下面的提到的求偏导数。

地址是：https://www.youtube.com/watch?v=exaWOE8jvy8&list=PLqnslRFeH2UrcDBWF5mfPGpqQDSta6VK4&index=3

安装

pytorch和tensorflow都是做人工智能的，prtorch的函数相对更友好，所以入门更高效。

pytorch官网地址：https://pytorch.org/get-started/locally/

使用pytorch前，先安装环境，我这里使用了vscode，安装完vscode后，在扩展里把python的包瞎按一些就行。

一般来讲学习都使用cpu版本。安装命令如下：

pip3 install torch torchvision torchaudio

如果使用gpu，安装命令如下：

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

安装完成后，执行代码，如果执行成功，则安装成功。

import torch
x =torch.ones(1)
print(x)

名词介绍

矩阵：就是我们的表。

向量(vector)：这种只有一行/一列的矩阵，叫向量。

1,1,0

二维张量(tensor2D):这有多行多列的矩阵叫二维张量。

1,1,0
1,0,1

三维张量(tensor3D)，就是三维数组。

多维张量同多维数组。

为什么叫向量或者张量?我们把[1,1,0]换个想象就行，[1,1,0]是自原点向x=1,y=1,z=0发射出去的线，那[1,1,0]就不在是个数据了，就变成张量了。但本质还是数据。这地方不要细究，理解就可以了，毕竟我们不是研究数学的。

代码入门

使用pytorch进行张量的基础。

import torch
import numpy as np
x=torch.empty(1) # 创建一个只有一个元素的向量(vector)，元素值是未定义的，未定义的就是0，打印出来是【0.】，这是因为默认的元素类型是float32
print(x)
x=torch.empty(3)  # 创建一个有三个元素的向量(vector)，元素值是未定义的
print(x)
x=torch.empty(3,2)  # 创建一个矩阵，，元素值是未定义的
print(x) 

x=torch.rand(3,2)  # 创建一个3*2的矩阵，并随机赋值
print(x)
x=torch.zeros(3,2)  # 创建一个3*2的矩阵，并赋值0
print(x)

x=torch.ones(2,2)  # 创建一个2*2的矩阵，并赋值1，打印出来是【1.】
print(x)
print("打印类型")
print(x.dtype) #dtype是data type，会打印出元素的类型，打印内容是torch.float32
x=torch.ones(3,3,dtype=torch.int)  # 创建一个3*3的矩阵，并赋值1，打印出来是【1】，这会就不带.了
print(x)
x=torch.ones(3,3,dtype=torch.double)  # 创建一个3*3的矩阵，并赋值1，打印出来是【1.】，double类型又带.了
print(x)
print(x.size()) #size是个函数，这样打印会打印出toString()的感觉，值是【torch.Size([3, 3])】
print(x.size().numel()) # 元素个数，值是9
x=torch.tensor([2.2,3.1]) # 自定义张量
print(x)
print("===========加法============")
x=torch.ones(3,3,dtype=torch.int)  # 创建一个3*3的矩阵，并赋值1，打印出来是【1】，这会就不带.了
print(x)
y =torch.ones(3,3,dtype=torch.int)
print(y)
z=x+y #矩阵相加
print(z)
z=torch.add(x,y) #矩阵相加
print(z)
print("===========计算print(y.add_(x))============")
print(y.add_(x)) #把x加到y中去
print("===========减法============")
z=x-y #矩阵相减
print(z)
z=torch.sub(x,y) #矩阵相减
print(z)
print("===========计算print(y.sub_(x))============")
print(y.sub_(x)) #把x减去从y中
print("===========乘法============") #这个乘法是元素相对的相乘，而不是线性代数的 A23*A32
z=x*y #矩阵相乘
print(z)
z=torch.mul(x,y)
print(z)
print(y.mul_(x))
print("===========除法============")
z=x/y #矩阵相乘除
print(z)
z=torch.div(x,y)
print(z)
print("===========列表============")
x=torch.rand(5,4)  # 创建一个3*2的矩阵，并随机赋值
print(x[:,0]) #打印全部行，但只取第一列
print(x[0,:]) #打印全部列，但只取第一行
print(x[0,0]) #打印i=0 j=0的元素
print(x[1,1].item()) #如果只取一个元素值，则可以取他的真实值
print(x)
print("===========view可以resize tensor============")
x=torch.rand(5,4)
y=x.view(20) #返回一个新的张量，这个是返回一个1行的20个元素的张量
print(y)
y=x.view(-1,10)
print(y) # 这个是返回2行，每行10个,他做了自动适配
print(y.size())#输出size
#print(x.view(-1,7)) # 这个自动适配不了，因为不能被7整除
print("===========numpy numpy只能在cpu上使用，不能在gpu上使用============")
a=torch.ones(5) #行向量，值是1，元素是5
b=a.numpy() #返回 numpy.ndarray类型的numpy下的张量，相当于转了类型，用于计算，该函数有参数 默认是false，表示使用cpu
print(b,type(b))
 #这里虽然a转了类型到b，但b和a是对象封装，引用地址一样 所以当我们给a+1时，b也会+1
a.add_(1)
print(a)
print(b)#虽然a b类型不一样，但值都改变了
print("===========从numpy.ndarray转成tensor张量的方式============")
a = np.ones(5) #行向量 5元素 值是1
b =torch.from_numpy(a) #numpy的ndarray转tensor 同样是装箱拆箱 修改a的值 b也会变
a+=1
print(b)
print(a)
print("===========gpu============")
if(torch.cuda.is_available()):
    #CUDA 是指 NVIDIA 的并行计算平台和编程模型，它利用图形处理单元 (GPU) 的处理能力来加速计算密集型任务
    device =torch.device("cuda") #获取cuda驱动
    x=torch.ones(5,device=device)#创建时指定了使用cpu的内存
    y=torch.ones(5)#创建时使用cpu的内存
    y=y.to(device)#将y转到gpu
    z=x+y #这个操作是在gpu的内存上进行了
    #z.numpy()#这个不能执行，因为z在gpu的内存上
    z =z.to("cpu") #转回到cpu
else:
    print("this is cpu")

requires_grad例子。

这里要点高数基础。

首先是导数，这个大家忘了的可以百度一下。

偏导数：这个就是f(x,y)=x+y这样的函数求导，只是对x求导时，把y当常量c，反之亦然。

print("===========requires_grad 例子1============")
#使用自动微分（autograd）
x=torch.ones(5,requires_grad=True) #默认requires_grad是false  1,计算梯度：requires_grad 是一个布尔参数，用于指定一个张量是否需要计算梯度 2,自动求导：使用 requires_grad=True 的张量进行的所有操作都会被记录，以便稍后使用 backward() 方法进行自动求导。
print(x)
# 对张量进行一些操作
y = x + 2
print(y)
# 再进行一些操作
z = y * y * 3
print("======分割线1=====")
print(z)
out = z.mean() #是一个张量操作，它计算张量 z 的所有元素的平均值。 看做f(x)=(x1+x2+x3+x4)/4 然后对每个x求偏导，在把值带回去
print("======分割线2=====")
print(out)
# 进行反向传播，计算梯度
out.backward()
print("======分割线3=====")
print(x.grad)  # 输出x的梯度
print("===========requires_grad 例子2============")
# 创建一个张量，并指定需要计算梯度
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
# 定义一个标量函数 平方在求和 相当于函数 f()= x1²+ x2²,+ x3²
y = x.pow(2).sum()
# 进行反向传播，计算梯度 x`的梯度，它对应于函数 f(x1,x2,x3)= x1²+ x2²+ x3², 三个偏导数就是 2x1,2x2,2x3,带入tensor的值 即'[2x1，2x2，2x3]
y.backward()
# 输出 x 的梯度
print(x.grad)  # 输出 tensor([2., 4., 6.])
print("===========requires_grad 例子3============")
# 创建一个张量，并指定需要计算梯度
x = torch.tensor([[1.0, 2.0],[4.0, 5.0]], requires_grad=True)
# 定义一个标量函数 平方在求和 相当于函数 f()= x1²+ x2²+ x3²+ x4²
y = x.pow(2).sum()
# 进行反向传播，计算梯度 x`的梯度，这里是2*2矩阵，但计算的时候，就按元素个数算x，没有行列ij。
# 它对应于函数 f(x1,x2,x3,x4)= x1²+ x2²,+ x3²+ x4², 四个偏导数就是 2x1,2x2,2x3,2x4,带入tensor的值 即'[2x1，2x2，2x4,2x5]
y.backward()
# 输出 x 的梯度
print(x.grad)  # 输出 tensor([[2, 4][8,10]])

基础学习就先到这。

---

注：此文章为原创，任何形式的转载都请联系作者获得授权并注明出处！

---

---

若您觉得这篇文章还不错，请点击下方的【推荐】，非常感谢！

https://www.cnblogs.com/kiba/p/18346596