前言

其实学习人工智能不难,就跟学习软件开发一样,只是会的人相对少,而一些会的人写文章,做视频又不好好讲。
比如,上来就跟你说要学习张量,或者告诉你张量是向量的多维度等等模式的讲解;目的都是让别人知道他会这个技术,但又不想让你学。
对于学习,多年的学习经验,和无数次的回顾学习过程,都证明了一件事,如果一篇文章,一个视频,一个课程,我没学明白,那问题一定不在我,而是上课的主动或被动的不想让我学会,所以,出问题的一定是学习资料。
比如英语,当真会了以后,再回去看自己之前学过的课,就知道了,那是英语老师没好好教,哪有真正想让你学会英语的人,会告诉你【come=来,out=出去】呀,认认真真按高中大学老师教的方法学习英语。记单词背词组,一百年学不会英语。
比如线性代数,等会了以后,再回去看之前看不懂的课程视频,就知道了,是上课老师估计模糊的关键信息。
学习软件开发,相信大家也都有类似的经验,当你想学一个知识点时,各种搜索,就是看不懂,最后学会的原因只有两种,1,你找到了真正的教你知识的文章,2,你通过搜索的信息,自己悟了出来。这其实就是在证明,绝大多数的文章和视频都不想真正教你,包括正规学校的老师和教材。

入门学习

首先,介绍一下我学习的资料,我通过一通搜索,终于找到了最好的学习资料,该视频是认真教你学习的,唯一的缺点可能就是,上课的人说的是英语,有点印度口音。不过,个人感觉他带点口语,反而更好听懂。
重点关注一下下面单词视频里会多次提到,注意了后就不会被英语卡住了。
numpy:这个单词,这不是个单词,但是是python的库。
vector:向量,下面有解释。
tensor:张量,下面有解释。
gradient:梯度,指的就是我下面的提到的求偏导数。
地址是:
https://www.youtube.com/watch?v=exaWOE8jvy8&list=PLqnslRFeH2UrcDBWF5mfPGpqQDSta6VK4&index=1

安装

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

标签: none

添加新评论