李沐深度学习记录1:零碎知识记录、08线性回归

简要记录,以便查阅~

一、零碎知识

python 复制代码
x.numel():看向量或矩阵里元素个数
A.sum():向量或矩阵求和,axis参数可对某维度求和,keepdims参数设置是否保持维度不变
A.cumsum:axis参数设置沿某一维度计算矩阵累计和

x*y:向量的按元素乘法
torch.dot(x,y):向量的点乘(点积or内积),结果是标量。公式,向量a点积向量b=|a||b|cos两向量夹角。向量点积即x的转置与向量y相乘,即对应元素相乘相加得数值
torch.sum(x*y):计算向量点积的另一方式,执行向量的按元素乘法得向量,再对向量求和。

torch.mv(A,X):矩阵向量积,矩阵乘以向量

A*B:矩阵的按元素乘法,称为Hadamard积。
torch.mm(A,B):矩阵乘法。但是注意,高维矩阵(二维以上)不可以使用mm(),应当使用matmul().

torch.abs(x).sum():计算向量的L1范数,即先计算各项绝对值,再求和。
torch.norm(x):计算向量的L2范数。L2范数是向量元素平方和的平方根
torch.norm(A):类似于向量的L2范数,矩阵A的Frobenius范数是矩阵元素平方和的平方根。

二、线性回归从零开始实现

python 复制代码
%matplotlib inline
import random
import torch
from d2l import torch as d2l

#生成数据集
#构建synthetic_data函数,给定w、b和数据样本个数num_examples,给出随机合成的数据集,返回数据样本X和数据标签y
def synthetic_data(w,b,num_examples):#@save
    #生成y=Xw+b+噪声
    X=torch.normal(0,1,(num_examples,len(w)))#随机生成样本值服从均值为0标准差为1的正态分布。样本数据矩阵为(样本量,样本特征维度)
#     print('X:',X,'\nX的形状:',X.shape)  #torch.Size([1000, 2])
    y=torch.matmul(X,w)+b #矩阵乘法。得到数据X在权重w和偏差值b下的对应y值
#     print('y:',y,'\ny的形状:',y.shape)  #torch.Size([1000])
    y+=torch.normal(0,0.01,y.shape) #随机为y添加服从均值0标准差0.01的正态分布的噪声值,噪声值形状与y相同
#     print('y:',y,'\ny的形状:',y.shape)  #torch.Size([1000])
#     print('reshape后y的形状:',y.reshape((-1,1)).shape,'\ny:',y)  #reshape后y的形状: torch.Size([1000, 1]) 
    return X,y.reshape((-1,1))  #返回数据X和标签y

true_w=torch.tensor([2,-3.4]) #权重w
true_b=4.2
features,labels=synthetic_data(true_w,true_b,1000)  #feature即返回的X数据,指的二维数据样本;labels即标签值
print('features:',features[0],'\nlabel:',labels[0])
print('features:',features[0:5],'\nlabel:',labels[0:5])
python 复制代码
#直观观察数据样本features和labels的线性关系
d2l.set_figsize()
d2l.plt.scatter(features[:,1].detach().numpy(),labels.detach().numpy(),1);#利用数据样本X的第1维特征和数据标签y作散点图。最后的1表示标记点的大小
python 复制代码
#如果使用X的第0维特征
d2l.set_figsize()
d2l.plt.scatter(features[:,0].detach().numpy(),labels.detach().numpy(),1);
python 复制代码
#读取数据集   
#定义data_iter函数,该函数接收批量大小、特征矩阵和标签向量作为输入,生成大小为batch_size的小批量。
def data_iter(batch_size,features,labels):
    num_examples=len(features)
    indices=list(range(num_examples)) #将0-总样本数间的所有数字保存在一个list中
    random.shuffle(indices) #将list中的数值随机打乱,也即做到之后随机取数据
    for i in range(0,num_examples,batch_size):  #从0开始到最后样本总数,每次跳batch_size的大小来取i,即每批数据的第一个数据的下标值
        batch_indices=torch.tensor( indices[i:min(i+batch_size,num_examples)] ) #从数据i开始,连着取batchsize大小的数据。min(,)是防止最后数据不足batchsize时,将最后的数据取为一个batch即可
        yield features[batch_indices],labels[batch_indices]  #根据前面所得的indices来取对应的features和labels
        #yield是返回两部分features,labels

batch_size=10
for X,y in data_iter(batch_size,features,labels):
    print(X,'\n',y) 
    break  #只输出一次X,y便跳出了
python 复制代码
#初始化模型参数
w=torch.normal(0,0.01,size=(2,1),requires_grad=True)
b=torch.zeros(1,requires_grad=True)

#定义模型
def linreg(X,w,b):  #@save
    #线性回归模型
    return torch.matmul(X,w)+b

#定义损失函数
def squared_loss(y_hat,y):#@save
    #均方损失
    return (y_hat-y.reshape(y_hat.shape))**2/2
    
#定义优化算法
def sgd(params,lr,batch_size):#@save  #params是一个list,里面包含w和b
    #小批量随机梯度下降
    with torch.no_grad():
        for param in params:
            param-= lr * param.grad / batch_size  #除以batch_size是因为上面计算损失时没有除以batchsize计算均值
            param.grad.zero_()  #每次更新完后,要将梯度置0,这样下次计算梯度时不会在上次计算的梯度上累加

#训练
lr=0.03
num_epochs=3
net=linreg
loss=squared_loss

for epoch in range(num_epochs):
    for X,y in data_iter(batch_size,features,labels):
        l=loss(net(X,w,b),y)  #计算y预测值和y之间的损失,返回l向量的形状是(batch_size,1)
        l.sum().backward() #将l中所有样本损失求和,再反向传播计算梯度
        sgd([w,b],lr,batch_size) #利用优化算法更新参数
    with torch.no_grad():  #前面训练一轮后,输出计算一下当前的损失,这时不计算梯度
        train_l=loss(net(features,w,b),labels)
        print(f'epoch{epoch+1},loss{float(train_l.mean()):f}')
python 复制代码
print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

三、线性回归的简洁实现

python 复制代码
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l

#生成数据集
true_w=torch.tensor([2,-3.4])
true_b=4.2
features,labels=d2l.synthetic_data(true_w,true_b,1000)

#读取数据集
def load_array(data_arrays,batch_size,is_train=True):
    #构造一个pytorch数据迭代器
    dataset=data.TensorDataset(*data_arrays) 
    #将数据数组转换为TensorDataset对象。data_arrays是包含数据的数据元组。*符号表示解压缩元组,使其成为函数参数
    return data.DataLoader(dataset,batch_size,shuffle=is_train) #每次随机从中挑选batchsize大小的数据,随机打乱

batch_size=10
data_iter=load_array((features,labels),batch_size) #这里的data_iter和之前手动创建的data_iter一样

next(iter(data_iter))
#iter()函数是将可迭代对象转换成迭代器。next()是python内置的函数,用于获取迭代器中的下一元素。


#next(iter(data_iter))这一行代码等价于下面的代码
#for X,y in data_iter:
#    print(X,'\n',y) 
#    break  #只输出一次X,y便跳出了
python 复制代码
#定义模型
#nn是神经网络的缩写
from torch import nn
net=nn.Sequential(nn.Linear(2,1)) #制定输入输出维度,分别是2和1。Sequential可理解为存放layer的list

#初始化参数
#net[0]访问网络层layer,weight即访问它的权重w,data即权重的值,normal_表示用均值为0标准差为0.01的数替换掉data的值
net[0].weight.data.normal_(0,0.01)
net[0].bias.data.fill_(0)  #同理将偏差值设置为0

#定义损失函数
loss=nn.MSELoss()  #MSELoss()也称平方L2范数,返回所有样本损失的平均值

#定义优化算法
trainer=torch.optim.SGD(net.parameters(),lr=0.03) #需要指定优化的参数以及优化算法所需的超参数字典

#训练
num_epochs=3
for epoch in range(num_epochs):
    for X,y in data_iter:
        l=loss(net(X),y) #调用net(X)前向计算预测值,将其与y真实值传入loss计算损失
        trainer.zero_grad()  #计算梯度前,现将优化器梯度清零
        l.backward()#反向传播计算梯度
        trainer.step()#进行模型更新
    l=loss(net(features),labels) #与之前一样,扫完一遍数据后计算一下loss
    print(f'epoch {epoch+1},loss {l:f}')
相关推荐
珠海新立电子科技有限公司2 小时前
FPC柔性线路板与智能生活的融合
人工智能·生活·制造
IT古董2 小时前
【机器学习】机器学习中用到的高等数学知识-8. 图论 (Graph Theory)
人工智能·机器学习·图论
曼城周杰伦2 小时前
自然语言处理:第六十三章 阿里Qwen2 & 2.5系列
人工智能·阿里云·语言模型·自然语言处理·chatgpt·nlp·gpt-3
余炜yw3 小时前
【LSTM实战】跨越千年,赋诗成文:用LSTM重现唐诗的韵律与情感
人工智能·rnn·深度学习
莫叫石榴姐3 小时前
数据科学与SQL:组距分组分析 | 区间分布问题
大数据·人工智能·sql·深度学习·算法·机器学习·数据挖掘
96773 小时前
对抗样本存在的原因
深度学习
如若1234 小时前
利用 `OpenCV` 和 `Matplotlib` 库进行图像读取、颜色空间转换、掩膜创建、颜色替换
人工智能·opencv·matplotlib
YRr YRr4 小时前
深度学习:神经网络中的损失函数的使用
人工智能·深度学习·神经网络
ChaseDreamRunner4 小时前
迁移学习理论与应用
人工智能·机器学习·迁移学习
Guofu_Liao4 小时前
大语言模型---梯度的简单介绍;梯度的定义;梯度计算的方法
人工智能·语言模型·矩阵·llama