中国旅游网站模板,怎样做自己的公司网站,微信小程序开发大赛,网页交互设计一、overview 基于pytorch的深度学习的四个步骤基本如下#xff1a; 二、线性模型 - Linear Model 基本概念
数据集分为测试集和训练集#xff08;训练集、开发集#xff09;训练集#xff08;x#xff0c;y#xff09;测试集只给#xff08;x#xff09;过拟合#…一、overview 基于pytorch的深度学习的四个步骤基本如下 二、线性模型 - Linear Model 基本概念
数据集分为测试集和训练集训练集、开发集训练集xy测试集只给x过拟合模型学得太多导致性能不好开发集测验模型泛化能力zip从数据集中按数据对儿取出自变量x_val和真实值y_val 本例中进行人工training穷举法定义前向传播函数forward定义损失函数lossMSE平均平方误差zip从数据集中按数据对儿取出自变量x_val和真实值y_val
import numpy as np
import matplotlib.pyplot as pltx_data [1.0,2.0,3.0]
y_data [2.0,4.0,6.0]def forward(x):#定义模型return x * wdef loss(x,y):#定义损失函数y_pred forward(x)return (y_pred - y) * (y_pred - y)w_list[]#权重
mse_list[]
for w in np.arange(0.0,4.1,0.1):print(w,w)l_sum 0for x_val,y_val in zip(x_data,y_data):y_pred_val forward(x_val)loss_val loss(x_val,y_val)l_sum loss_valprint(\t,x_val,y_val,y_pred_val,loss_val)print(MSE,l_sum / 3)w_list.append(w)mse_list.append(l_sum / 3)plt.plot(w_list,mse_list)
plt.ylabel(Loss)
plt.xlabel(w)
plt.show()注模型训练可视化
wisdom可视化工具包 三、梯度下降 - Gradient Descent 3.1、梯度下降
基于cost function 即所有样本 如我们想要找到w的最优值 贪心思想每一次迭代得到局部最优往梯度的负方向走梯度下降算法很难找到全局最优但是在深度学习中损失函数中全局最优最有很少出现但会出现鞍点梯度 0 import numpy as np
import matplotlib.pyplot as pltw 1.0
x_data [1.0,2.0,3.0]
y_data [2.0,4.0,6.0]def forward(x):return x * wdef cost(xs,ys):cost 0for x,y in zip(xs,ys):y_pred forward(x)cost (y_pred-y)**2return cost / len(xs)def gradient(xs,ys):grad 0for x,y in zip(xs,ys):grad 2 * x * ( x * w - y)return grad / len(xs)epoch_list[]
cost_list[]
print(Predict (before training),4,forward(4))
for epoch in range(100):cost_val cost(x_data,y_data)grad_val gradient(x_data,y_data)w - 0.01 * grad_valprint(Epoch,epoch,w,w,loss,cost_val)epoch_list.append(epoch)cost_list.append(cost_val)
print(Predict (after training),4,forward(4))print(Predict (after training),4,forward(4))
plt.plot(epoch_list,cost_list)
plt.ylabel(Loss)
plt.xlabel(epoch)
plt.show()注训练过程会趋近收敛若生成图像局部震荡很大可以进行指数平滑若图像发散则训练失败通常原因是因为学习率过大 3.2、随机梯度下降 Stochastic Gradient Descent
基于单个样本的损失函数 —— 因为函数可能存在鞍点使用一个样本就引入了随机性 此时梯度更新公式为 与之前的区别
cost改为loss梯度求和变为单个样本训练过程中要对每一个样本求梯度进行更新由于两个样本的梯度下降不能并行化时间复杂度太高所以折中的方式使用 Mini-Batch 批量随机梯度下降若干个一组后续将会涉及
import numpy as np
import matplotlib.pyplot as pltw 1.0
x_data [1.0,2.0,3.0]
y_data [2.0,4.0,6.0]def forward(x):return x * wdef loss(x,y):y_pred forward(x)return (y_pred-y)**2def gradient(x,y):return 2 * x * (x * w - y)loss_list[]
epoch_list[]
print(Predict (before training),4,forward(4))for epoch in range(100):for x,y in zip(x_data,y_data):grad gradient(x,y)w w - 0.01 * gradprint(\tgrad,x,y,grad)l loss(x,y)loss_list.append(l)epoch_list.append(epoch)print(progress,epoch,w,w,loss,l)print(Predict (after training),4,forward(4))
plt.plot(epoch_list,loss_list)
plt.ylabel(Loss)
plt.xlabel(epoch)
plt.show()四 、反向传播 - BackPropagation 对于复杂的网络
举例来讲两层神经网络 若进行线性变换不管多少层最终都可以统一成一种形式但为了让你不能在化简即提高模型复杂程度所以我们要对每一层最终的输出
加一个非线性的变化函数比如sigmiod 则层层叠加若需要求梯度的话就要用到 —— 链式求导
1、构建计算图 —— 前馈计算Forward先计算最终的loss 2、反馈Backward 来看一下最简单的线性模型中的计算图的计算过程 在pytorch中使用tensor类型的数据 import torch
import matplotlib.pyplot as pltx_data [1.0,2.0,3.0]
y_data [2.0,4.0,6.0]w torch.Tensor([1.0]) #注意这里一定要加[] 权重初始值
w.requires_grad Truedef forward(x):return x * w #因为w是Tensor这里的运算符已经被重载了x会进行自动转换即构造了计算图def loss(x,y):y_pred forward(x)return (y_pred - y) ** 2epoch_list []
loss_list []
print(Predict (before training),4,forward(4))for epoch in range(100):#sum0for x,y in zip(x_data,y_data):l loss(x,y) #只要一做backward计算图会释放会准备下一次的图l.backward()print(\tgrad:,x,y,w.grad.item()) #item将梯度数值直接拿出来为标量w.data w.data - 0.01 * w.grad.data #grad必须要取到data#sum l 但l为张量计算图进行加法计算会构造计算图将会发生溢出w.grad.data.zero_() #权重里面梯度的数据必须显式清零print(progress,epoch,l.item())epoch_list.append(epoch)loss_list.append(l.item())print(Predict (after training),4,forward(4))
plt.plot(epoch_list,loss_list)
plt.ylabel(Loss)
plt.xlabel(epoch)
plt.show() 五、利用PyTorch实现线性回归模型 - Linear Regression With PyTorch pytorch神经网络四步走 1、构建数据集2、设计模型用来计算y_hat3、构建损失函数和优化器我们使用pytorch封装的API4、训练周期前馈 反馈 更新 本例将使用 Mini-Batchnumpy有广播机制矩阵相加会自动扩充。 使用pytorch的关键就不在于求梯度了而是构建计算图这里使用仿射模型也叫线性单元。 代码实现
import torch
import matplotlib.pyplot as plt# 1、准备数据
x_data torch.Tensor([[1.0],[2.0],[3.0]])
y_data torch.Tensor([[2.0],[4.0],[6.0]])# 2、构建模型
class LinearModel(torch.nn.Module):def __init__(self): #构造函数super(LinearModel,self).__init__()self.linear torch.nn.Linear(1,1) #构造一个对象def forward(self,x):y_pred self.linear(x) #实现可调用对象return y_predmodel LinearModel()# 3、构造损失函数和优化器
criterion torch.nn.MSELoss(size_averageFalse) #继承nn.Module是否求平均
optimizer torch.optim.SGD(model.parameters(),lr0.01) #是一个类不继承nn.Module不会构建计算图lr学习率epoch_list []
loss_list []for epoch in range(100):# 前馈 计算 y_haty_pred model(x_data)# 前馈 计算损失loss criterion(y_pred,y_data) #loss标量print(epoch,loss) # loss是一个对象打印将会自动调用__str__()optimizer.zero_grad() # 所有权重梯度归零# 反馈 反向传播loss.backward()# 自动更新权重进行更新optimizer.step()epoch_list.append(epoch)loss_list.append(loss.item())# Output weight and bias
print(w ,model.linear.weight.item())
print(b ,model.linear.bias.item())# Test Model
x_test torch.Tensor([4.0])
y_test model(x_test)
print(y_pred ,y_test.data)
plt.plot(epoch_list,loss_list)plt.ylabel(Loss)
plt.xlabel(epoch)
plt.show() 六、逻辑斯蒂回归 - Logistics Regression 逻辑斯蒂回归 —— 虽然叫回归模型但既可解决分类模型也可解决回归模型本节是讲的二分类背景是学习多少小时能够考试通过训练好模型以后直接用来预测4小时的学习能够通过的概率是多大 torchvision提供相应的数据集可以指定需要的数据集train表示需要训练集还是测试集。分类问题我们的输出为概率将线性模型输出的实数空间映射到[0,1]之间logist函数即可完成这个映射。logist函数为饱和函数是sigmoid中最典型的。 其他的sigmoid函数 所以现在我们的模型 对应的loss也要发生改变现在输出的是一个分布不再是一个数值
所以现在相比较的是两个分布之间的差异可以选择用KL散度或者cross-entropy(交叉熵)
交叉熵举例交叉熵越大越好 在本例中我们采用二分类的交叉熵因为加了负号所以这里的loss越小越好称为BCE损失 criterion torch.nn.BCELoss(size_averageFalse) #继承nn.Module是否给每个批量求均值设置与否关键会影响学习率的设置因为如果损失变小了将来求出来的导数也会乘上这个常数 import torchvision
import torch.nn.functional as F
import torch
import matplotlib.pyplot as plt# 1、准备数据
x_data torch.Tensor([[1.0],[2.0],[3.0]])
y_data torch.Tensor([[0],[0],[1]])# 2、构建模型
class LogisticRegressionModel(torch.nn.Module):def __init__(self):super(LogisticRegressionModel,self).__init__()self.linear torch.nn.Linear(1,1)def forward(self,x):y_pred F.sigmoid(self.linear(x))return y_predmodel LogisticRegressionModel()# 3、构造损失函数和优化器
criterion torch.nn.BCELoss(size_averageFalse) #继承nn.Module是否给每个批量求均值
optimizer torch.optim.SGD(model.parameters(),lr0.01) #是一个类不继承nn.Module不会构建计算图lr学习率epoch_list []
loss_list []for epoch in range(1000):# 前馈 计算 y_haty_pred model(x_data)# 前馈 计算损失loss criterion(y_pred,y_data) #loss标量print(epoch,loss) # loss是一个对象打印将会自动调用__str__()optimizer.zero_grad() # 所有权重梯度归零# 反馈 反向传播loss.backward()# 自动更新权重进行更新optimizer.step()epoch_list.append(epoch)loss_list.append(loss.item())# Output weight and bias
print(w ,model.linear.weight.item())
print(b ,model.linear.bias.item())# Test Model
x_test torch.Tensor([4.0])
y_test model(x_test)
print(y_pred ,y_test.data)
plt.plot(epoch_list,loss_list)plt.ylabel(Loss)
plt.xlabel(epoch)
plt.show() 七、处理多维特征的输入 - Multiple Dimension lnput 引例糖尿病数据集分类任务 行称为样本(Sample) 数据库中称为记录(record)
列称为特征 数据库中称为字段 注sklearn中提供一个关于糖尿病的数据集可作为回归任务的数据集 Mlultiple Dimension Loqistic Regression Model
x可以看成一个向量每一个x都要和w进行相乘我们就可以写成图中上面的红色部分因为标量的转置还是他自身为了方便演示我们可以写成转置的形式。 即 再来看下Mini-Batch(N samples)的情况 为什么这里要将方程运算转换成矩阵运算 即 向量形式呢
———— 我们可以利用并行运算的能力提高运行速度。 则只需将上一节的代码中数据准备和构建模型进行修改即可 Logistics回归只有一层神经网络若我们构造一个多层神经网络 将矩阵看成一种空间变换的函数这里的(8,2)是指将一个任意八维空间的向量映射到一个二维空间上注意是线性的而我们所做的空间变换不一定是线性的 所以我们想要多个线性变换层通过找到最优的权重把他们组合起来来模拟一个非线性变换 注意绿色框中我们引入的 即激活函数 在神经网络中我们通过引入激活函数给线性变换加入非线性操作这样就使得我们可以去拟合相应的非线性变换。 对于本例 我们使用 Example: Artificial Neural Network 1、建立数据集
import numpy as np
import torchxy np.loadtxt(./dataset/diabetes.csv.gz, delimiter,, dtypenp.float32)
x_data torch.from_numpy(xy[:, :-1])
y_data torch.from_numpy(xy[:, [-1]])
分隔符为为什么用float32因为常用游戏显卡只支持32位浮点数只有特别贵的显卡才支持64位由于课程中导入的数据是anaconda安装工具包中的自带的压缩文本数据所以直接采用numpy中的loadtxt读取这个函数可以直接读取Linux下压缩的格式此处是.gz因为我们的x和y是放在一起的所以 -1表示不要最后一列 → 拿出来前八列注意y所有行拿出来需要加中括号拿出来矩阵 → 拿出最后一列
2、模型建立
class Model(torch.nn.Module):def __init__(self):super(Model, self).__init__()self.linear1 torch.nn.Linear(8, 6)self.linear2 torch.nn.Linear(6, 4)self.linear3 torch.nn.Linear(4, 1)self.sigmoid torch.nn.Sigmoid()def forward(self, x):x self.sigmoid(self.linear1(x))x self.sigmoid(self.linear2(x))x self.sigmoid(self.linear3(x))return xmodel Model()注意上次调用的是nn.Function下的sigmoid但是这里调用的是nn下的一个模块forward函数中如果是一串就用一个x上面的输出是下面的输入 3、构造损失函数和优化器
criterion torch.nn.BCELoss(size_averageTrue)
optimizer torch.optim.SGD(model.parameters(), lr0.1) 4、模型训练虽然是mini-batch的风格 但这里还是全部数据下一节会涉及
for epoch in range(100):# forwardy_pred model(x_data)loss criterion(y_pred, y_data)print(epoch, loss.item())# backwordoptimizer.zero_grad()loss.backward()# updateoptimizer.step()可以尝试不同的激活函数对结果的影响
torch.nn — PyTorch 2.1 documentation
Visualising Activation Functions in Neural Networks - dashee87.github.io
注意Relu函数取值是0到1如果最后的输入是小于0的那么最后输出会是0但我们可能会算In0所以一般来说会将最后一层的激活函数改成sigmoid。 八、加载数据集 - Dataset and DataLoader Dataset加载数据集支持我们以索引方式拿出样本Dataloader拿出一组Mini-Batch快速使用 三个概念EpochBatch-sizeIterations
若使用Mini-Batch我们的训练循环要写成嵌套循环 外层循环每一寸循环是一次epoch训练周期内层循环每一次循环执行一个batch对batch进行迭代Epoch所有的样本都进行了一次训练Batch-Size每一次训练的样本数量IterationBatch分了多少个即内层迭代了多少次 Dataloader 分组并做成可迭代的batch dataset抽象类 不可实例化dataloader可以实例化数据集类里面有三个函数这三个函数较为固定分别自己的作用 继承Dataset后我们必须实现三个函数 __len__()帮助我们返回数据集大小getitem__()帮助我们通过索引找到某个样本__init__()是初始化函数之后我们可以提供数据集路径进行数据的加载 Dataset的 init 中如果数据量较少可以导入所有的数据若数据较大图像、语音无结构数据
import numpy as np
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import matplotlib.pyplot as pltepoch_list []
loss_list []class DiabetesDataset(Dataset):def __init__(self,filepath):xy np.loadtxt(filepath, delimiter,, dtypenp.float32)self.len xy.shape[0] #(n,9)self.x_data torch.from_numpy(xy[:, :-1])self.y_data torch.from_numpy(xy[:, [-1]])def __getitem__(self, index):return self.x_data[index],self.y_data[index]def __len__(self):return self.lendataset DiabetesDataset(D:\python_project\diabetes.csv.gz)
train_loader DataLoader(datasetdataset,batch_size32,shuffleTrue,num_workers1)class Model(torch.nn.Module):def __init__(self):super(Model, self).__init__()self.linear1 torch.nn.Linear(8, 6)self.linear2 torch.nn.Linear(6, 4)self.linear3 torch.nn.Linear(4, 1)self.sigmoid torch.nn.Sigmoid()def forward(self, x):x self.sigmoid(self.linear1(x))x self.sigmoid(self.linear2(x))x self.sigmoid(self.linear3(x))return xmodel Model()criterion torch.nn.BCELoss(reductionmean)
optimizer torch.optim.SGD(model.parameters(), lr0.01)if __name__ __main__:for epoch in range(100):for i,data in enumerate(train_loader,0):print(1)# 1、准备数据inputs, labels data# 2、前馈y_pred model(inputs)loss criterion(y_pred,labels)print(epoch,i,loss.item())# 3、反馈optimizer.zero_grad()loss.backward()# 4、更新optimizer.step()epoch_list.append(epoch)loss_list.append(loss.item())plt.plot(epoch_list,loss_list)plt.ylabel(Loss)plt.xlabel(epoch)plt.show() 不是我结果怎这样 更多数据集 九、多分类问题 - Softmax分类器 Sigmoid函数主要用于解决二分类问题它的特性在于将输入值映射到0和1之间的概率值。然而在多类别问题中我们需要将输入值映射到多个不同的类别上而不仅仅是0和1。如果我们尝试使用sigmoid函数来解决多类别问题我们需要将其进行扩展以支持多个类别。一种常见的方法是使用一对多One-vs-Rest策略其中针对每个类别训练一个独立的二分类模型。然后我们可以使用sigmoid函数将每个模型的输出转换为概率值。然而这种方法存在一些问题。首先由于每个模型都是独立训练的可能会导致类别之间存在冲突或重叠。其次sigmoid函数在处理极端情况时接近0或1容易饱和这可能会导致梯度消失或梯度爆炸问题对模型的训练造成困难。因此为了解决多类别问题通常会使用其他适合的函数如Softmax函数。Softmax函数可以将输入值映射到多个类别的概率分布同时保持概率之和为1。这样我们可以更好地处理多类别问题并避免sigmoid函数的限制。 Softmax层 因为只有一项结果会为0所以在算Loss时只算一项即可。 在pytorch中 具体例子 反看之前的题目
lmplementation of classifier to MNIST dataset ToTenser神经网络想要的输入比较小所以原始图像需要转变成一个图像张量 Normalize标准化 切换到 0,1 分布 参数为 均值 标准差类似四六级成绩因为我们选用小批量所以这里的N表示每个批量N个样本每个样本都是一维28x28的图像则输入为四阶张量但在全连接神经网络中要求输入必须是矩阵所以需要将1x28x28这个三阶张量 变为 一阶的向量则只要将图像的每一行拼起来即可一行即为784个元素所以可以使用view函数将输入变为二阶张量第一个参数为-1将来会自动算出对应值最后得到 Nx784 的矩阵注意最后一层不做激活 为什么每一层Linear层后都要加一层激活函数
在神经网络中每一层后加入激活函数有几个主要原因 引入非线性线性层只是对输入进行线性变换无法处理复杂的非线性关系。通过添加激活函数可以引入非线性使得神经网络能够学习更加复杂的特征和模式。 增强模型表达能力激活函数可以增加模型的表达能力使其能够适应更广泛的数据分布和任务。通过非线性变换激活函数可以将输入映射到更高维度的特征空间从而提取更多的有用信息。 解决梯度消失问题线性层的堆叠容易导致梯度逐渐消失的问题。激活函数的使用可以帮助传播梯度避免梯度在深层网络中过早地衰减。这对于训练深层神经网络至关重要。 使输出范围有限某些激活函数例如sigmoid函数、tanh函数可以将输出值限制在特定的范围内例如[0,1]或[-1,1]这有助于解决回归或分类问题中的数值稳定性和收敛性问题。
需要注意的是并非所有层都需要添加激活函数。例如在输出层进行回归任务时可以选择不使用激活函数或者使用恒等函数作为激活函数。在某些特定的网络架构中也可能会采用其他类型的层如BatchNormalization层、MaxPooling层来替代激活函数的作用。 代码实现
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim# 1、数据准备
batch_size 64
transform transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))
])train_dataset datasets.MNIST(root../dataset/mnist,trainTrue,downloadTrue,transformtransform)
train_loader DataLoader(train_dataset,shuffleTrue,batch_sizebatch_size)test_dataset datasets.MNIST(root../dataset/mnist,trainFalse,downloadTrue,transformtransform)
test_loader DataLoader(test_dataset,shuffleFalse,batch_sizebatch_size)# 2、构建模型
class Net(torch.nn.Module):def __init__(self):super(Net,self).__init__()self.l1 torch.nn.Linear(784,512)self.l2 torch.nn.Linear(512,256)self.l3 torch.nn.Linear(256,128)self.l4 torch.nn.Linear(128,64)self.l5 torch.nn.Linear(64,10)def forward(self,x):x x.view(-1,784)x F.relu(self.l1(x))x F.relu(self.l2(x))x F.relu(self.l3(x))x F.relu(self.l4(x))return self.l5(x)model Net()# 3、损失函数和优化器
criterion torch.nn.CrossEntropyLoss()
optimizer optim.SGD(model.parameters(),lr0.01,momentum0.5)# 4、训练和测试
def train(epoch):running_loss 0.0for batch_idx,data in enumerate(train_loader,0):inputs,target dataoptimizer.zero_grad()outputs model(inputs)loss criterion(outputs,target)loss.backward()optimizer.step()running_loss loss.item()if batch_idx % 300 299: # 每三百次迭代输出一次print([%d , %5d] loss: %.3f % (epoch 1 ,batch_idx 1,running_loss / 300))running_loss 0.0def test():correct 0total 0with torch.no_grad():for data in test_loader:images,labels dataoutputs model(images) # 输出为一个矩阵下面要求每一行最大值(即分类)的下标_,predicted torch.max(outputs.data,dim1)total labels.size(0)correct (predicted labels).sum().item()print(Accuracy on test set: %d %% % (100 * correct / total))if __name__ __main__:for epoch in range(10):train(epoch)test()
实验结果 为什么最后准确率上不去了
因为做图像时忽略了对局部信息的利用本例中使用的是全连接神经网络所有的元素都和其他元素都要产生联系所以首先我们的权重不够多其次我们在处理图像时更关系一些高抽象级别的特征我们现在用的是非常原始的特征
改进我们可以先对图像进行人工特征提取如傅里叶变换变换成频率的表示、小波
自动特征提取CNN • Reading the document: • https://pytorch.org/docs/stable/nn.html#crossentropyloss • https://pytorch.org/docs/stable/nn.html#nllloss • Try to know why: • CrossEntropyLoss LogSoftmax NLLLoss 部分文字参考于
【Pytorch深度学习实践】B站up刘二大人之SoftmaxClassifier-代码理解与实现(8/9)_softmax分类器代码-CSDN博客
视频及图片来源于
09.多分类问题_哔哩哔哩_bilibili
