构建简单的网络结构(二元分类的 Pytorch 实现)
最编程
2024-07-06 15:01:09
...
搭建一个简单的网络结构(Pytorch实现二分类)
搭建一个神经网络并进行训练的话,大致需要分为三步:
- 第一步是数据的处理,将数据整理成输入网络结构中合适的格式
- 第二步是网络的搭建,包括每层网络的结构和前向传播
- 第三步是网络的训练,包括损失计算,优化器选择,梯度清零,反向传播,梯度优化等
这里我们以简单的二分类来进行一个简单的网络搭建:
一、数据处理
首先来生成含200个样本的数据
#生成200个点的数据集,返回的结果是一个包含两个元素的元组 (X, y),X是点,y是x的分类
X, y = sklearn.datasets.make_moons(200, noise = 0.2)
并绘制出样本的散点图如下图所示:
save_path = "/data/wangweicheng/ModelLearning/SimpleNetWork"
plt.scatter(X[:,0],X[:,1],s=40,c=y,cmap=plt.cm.Spectral)
plt.savefig(f'{save_path}/dataset.png') #保存生成的图片
**可以看到我们生成了两类数据,分别用 0 和 1 来表示。**我们接下来将要在这个样本数据上构造一个分类器,采用的是一个很简单的全连接网络,网络结构如下:
这个网**络包含一个输入层,一个中间层,一个输出层。**中间层包含 3 个神经元,使用的激活函数是 tanh。当然,中间层的神经元越多,分类效果一般越好,但这个 3 层的网络对于我们的样本数据已经足够用了。我们来算一下参数数量:上图中一共有 6 6 = 12 条线,就是 12 个权重,加上 3 2 = 5 个 bias,一共 17 个参数需要训练。
最后我们将样本数据从 numpy 转成 tensor:,后面我们就可以进行网络的搭建了
# 将 NumPy 数组转换为 PyTorch 张量,并指定张量的数据类型
X = torch.from_numpy(X).type(torch.FloatTensor)
y = torch.from_numpy(y).type(torch.LongTensor)
二、网络搭建
# 搭建网络
class BinaryClassifier(nn.Module):
#初始化,参数分别是初始化信息,特征数,隐藏单元数,输出单元数
def __init__(self,n_feature,n_hidden,n_output):
super(BinaryClassifier, self).__init__()
#输入层到隐藏层的全连接
self.hidden = torch.nn.Linear(n_feature, n_hidden)
#隐藏层到输出层的全连接
self.output = torch.nn.Linear(n_hidden, n_output)
#前向传播,把各个模块连接起来,就形成了一个网络结构
def forward(self, x):
x = self.hidden(x)
x = torch.tanh(x) #激活函数
x = self.output(x)
return x
def predict(self,x):
#训练好之后,重新将x输入到网络中,进行测试
#softmax得到0到1的一个值
pred = F.softmax(self.forward(x),dim=1)
ans = []
#对不同点分别进行判断,如果第一个位置的数值大于第二个位置,就返回0,反之返回1
for t in pred:
if t[0]>t[1]:
ans.append(0)
else:
ans.append(1)
return torch.tensor(ans)
三、网络训练
选择损失函数CrossEntropyLoss
,以及梯度优化器 Adam:
#初始化模型
model = BinaryClassifier(2, 3, 2)
#定义损失函数,用于衡量模型预测结果与真实标签之间的差异。
loss_criterion = nn.CrossEntropyLoss()
#定义优化器,优化器(optimizer)用于更新模型的参数,以最小化损失函数并提高模型的性能
# model.parameters() 表示要优化的模型参数,lr=0.01 表示学习率(learning rate)为 0.01,即每次参数更新的步长。
optimizer = torch.optim.Adam(model.parameters(), lr = 0.01)
进行迭代,获取当前loss,清除上一次的梯度,进行梯度下降和反向传播,更新参数:
#训练的次数
epochs = 10000
#存储loss
losses = []
for i in range(epochs):
#得到预测值
y_pred = model.forward(X)
#计算当前的损失
loss = loss_criterion(y_pred, y)
#添加当前的损失到losses中
losses.append(loss.item())
#清除之前的梯度
optimizer.zero_grad()
#反向传播更新参数
loss.backward()
#梯度优化
optimizer.step()
if(i % 500 == 0):
print('loss: {:.4f}'.format(loss.item()))
查看 训练准确率:
print(accuracy_score(model.predict(X),y))
结果可视化:
def predict(x):
x = torch.from_numpy(x).type(torch.FloatTensor)
ans = model.predict(x)
return ans.numpy()
# 画出边框
def plot_decision_boundary(pred_func,X,y):
# 找到x,y的最大和最小值,并填充一些边框
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
h = 0.01
# 生成一个网格
xx,yy=np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
# 将两个展平后的一维数组 xx.ravel() 和 yy.ravel() 按列连接起来,生成一个二维数组,然后对这个点进行预测
Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
# 将预测结果 Z 重塑为与点网格 xx 相同的形状
Z = Z.reshape(xx.shape)
# 画出图像,绘制等高线图的代码
plt.contourf(xx, yy, Z, cmap=plt.cm.YlGnBu)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.binary)
plt.savefig(f'{save_path}/dataout.png')
plot_decision_boundary(lambda x : predict(x) ,X.numpy(), y.numpy())
输出结果:
结果还是不错的!
完整代码:GitHub
#引入必要的包
#数据处理的包
import matplotlib.pyplot as plt
from sklearn.cluster import SpectralClustering
import sklearn.datasets
import numpy as np
#搭建网络的包
import torch
import torch.nn as nn
import torch.nn.functional as F
#统计分数
from sklearn.metrics import accuracy_score
#生成200个点的数据集,返回的结果是一个包含两个元素的元组 (X, y),X是点,y是x的分类
X, y = sklearn.datasets.make_moons(200, noise = 0.2)
save_path = "/data/wangweicheng/ModelLearning/SimpleNetWork"
plt.scatter(X[:,0],X[:,1],s=40,c=y,cmap=plt.cm.Spectral)
plt.savefig(f'{save_path}/dataset.png') #保存生成的图片
# 将 NumPy 数组转换为 PyTorch 张量,并指定张量的数据类型
X = torch.from_numpy(X).type(torch.FloatTensor)
y = torch.from_numpy(y).type(torch.LongTensor)
# 搭建网络
class BinaryClassifier(nn.Module):
#初始化,参数分别是初始化信息,特征数,隐藏单元数,输出单元数
def __init__(self,n_feature,n_hidden,n_output):
super(BinaryClassifier, self).__init__()
#输入层到隐藏层的全连接
self.hidden = torch.nn.Linear(n_feature, n_hidden)
#隐藏层到输出层的全连接
self.output = torch.nn.Linear(n_hidden, n_output)
#前向传播,把各个模块连接起来,就形成了一个网络结构
def forward(self, x):
x = self.hidden(x)
x = torch.tanh(x) #激活函数
x = self.output(x)
return x
def predict(self,x):
#训练好之后,重新将x输入到网络中,进行测试
#softmax得到0到1的一个值
pred = F.softmax(self.forward(x),dim=1)
ans = []
#对不同点分别进行判断,如果第一个位置的数值大于第二个位置,就返回0,反之返回1
for t in pred:
if t[0]>t[1]:
ans.append(0)
else:
ans.append(1)
return torch.tensor(ans)
#初始化模型
model = BinaryClassifier(2, 5, 2)
#定义损失函数,用于衡量模型预测结果与真实标签之间的差异。
loss_criterion = nn.CrossEntropyLoss()
#定义优化器,优化器(optimizer)用于更新模型的参数,以最小化损失函数并提高模型的性能
# model.parameters() 表示要优化的模型参数,lr=0.01 表示学习率(learning rate)为 0.01,即每次参数更新的步长。
optimizer = torch.optim.Adam(model.parameters(), lr = 0.01)
#训练的次数
epochs = 10000
#存储loss
losses = []
for i in range(epochs):
#得到预测值
y_pred = model.forward(X)
#计算当前的损失
loss = loss_criterion(y_pred, y)
#添加当前的损失到losses中
losses.append(loss.item())
#清除之前的梯度
optimizer.zero_grad()
#反向传播更新参数
loss.backward()
#梯度优化
optimizer.step()
if(i % 500 == 0):
print('loss: {:.4f}'.format(loss.item()))
#进行预测
print(accuracy_score(model.predict(X),y))
def predict(x):
x = torch.from_numpy(x).type(torch.FloatTensor)
ans = model.predict(x)
return ans.numpy()
# 画出边框
def plot_decision_boundary(pred_func,X,y):
# 找到x,y的最大和最小值,并填充一些边框
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
h = 0.01
# 生成一个网格
xx,yy=np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
# 将两个展平后的一维数组 xx.ravel() 和 yy.ravel() 按列连接起来,生成一个二维数组,然后对这个点进行预测
Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
# 将预测结果 Z 重塑为与点网格 xx 相同的形状
Z = Z.reshape(xx.shape)
# 画出图像,绘制等高线图的代码
plt.contourf(xx, yy, Z, cmap=plt.cm.YlOrBr)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.binary)
plt.savefig(f'{save_path}/dataout.png')
plot_decision_boundary(lambda x : predict(x) ,X.numpy(), y.numpy())
上一篇: 使用 cavans-index.html 为图像添加水印
下一篇: Flutter 运行 MacOs 网络请求报错未处理异常:DioException [connection error]:...
推荐阅读
-
用 PyTorch 实现 VGG-16 在 CIFAR-10 数据集上的多类分类,取得了高达 90.97% 的精准度
-
用PyTorch简单实现基础神经网络的前向传播教程
-
构建简单的网络结构(二元分类的 Pytorch 实现)
-
大聪明教你学Java|Mybatis的一级缓存和二级缓存--🍊作者简介:不愿过河东,一个来自二线城市的程序员,致力于用 "猥琐 "的方法解决琐碎的问题,让复杂的问题变得简单易懂。支持作者:喜欢👍,关注💖,留言💌~! 前言。 在计算机世界中,缓存无处不在;操作系统有操作系统缓存,数据库会有数据库缓存,我们还可以利用中间件(如 Redis)来充当缓存。MyBatis 作为一个优秀的 ORM 框架,也用于缓存,所以今天我们就来谈谈 Mybatis 的一级缓存和二级缓存。 Mybatis 一级缓存 首先,我们来看一张图片👇。 我们在开发项目的过程中,如果打开Mybatis的SQL语句打印,经常会看到这样一句话:创建一个新的 SqlSession,其实这就是我们常说的 Mybatis 一级缓存。 Mybatis 的一级缓存也就是在执行一次 SQL 查询或 SQL 更新后,这条 SQL 语句并不会消失,而是被 MyBatis 缓存起来,当再次执行同样的 SQL 语句时,就会直接从缓存中提取出来,而不用再次执行 SQL 命令。第一级缓存也称为 SqlSession 级缓存。对数据库进行操作时,需要构建一个 SqlSession 对象,其中有一个用于存储缓存数据的数据结构(HashMap)。对象中有一个用于存储缓存数据的数据结构(HashMap)。不同 SqlSession 之间的缓存数据区域(HashMap)互不影响。 在我们的应用系统运行过程中,我们可能会在一个数据库会话中,执行多条查询条件相同的 SQL 语句,那么对于这种情况,你来进行设计,那么你会如何考虑呢?没错,就是加入缓存,MyBatis也是这么来处理的,如果是同一条SQL语句,会优先打入一级缓存,避免直接查询数据库,给数据库造成压力,提高性能。具体实现过程如下图所示👇 SqlSession 是一个接口,提供了一些 CRUD 方法,SqlSession 的默认实现类是 DefaultSqlSession,DefaultSqlSession 类持有 Executor 接口对象,Executor 的默认实现是 BaseExecutor 对象,每个 BaseExecutor 对象都有一个 PerpetualCache 缓存,即上图中的本地缓存。当用户发起查询时,MyBatis 会根据当前执行的语句生成一个 MappedStatement,并在本地缓存中进行查询,如果缓存被命中,查询结果会直接返回给用户;如果缓存未被命中,查询结果会直接返回给用户。如果缓存未命中,则查询数据库,将结果写入本地缓存,最后将结果返回给用户。这时候可能有小伙伴要说了:我还在控制台中看到 "关闭非事务性 SqlSession "这句话,说明我每次创建一个 SqlSession 到 SqlSession 结束都是关闭的,那么我的缓存还是有毛线用!😥 事情肯定不是我们想的那样,让我们继续👇。 🍊 getSqlSession 源代码
-
从导入模块、定义网络结构到训练和评估网络性能,10 分钟即可掌握在 PyTorch 中构建深度神经网络的基本组件、步骤和代码实现。
-
PyTorch 深度学习项目 100 例】--基于 pytorch 使用 LSTM 实现本篇新闻的分类任务 | 例 9
-
Pytorch_第 4 部分_使用 pytorch 快速构建用于二元分类任务的神经网络(包括示例)
-
Pytorch 简单实现 GAN 的细节和原理
-
Android 开发中 nodpi、xhdpi、hdpi、mdpi、ldpi 的概念 - 术语和概念 屏幕尺寸 屏幕的物理尺寸,基于屏幕的对角线长度(如 2.8 英寸、3.5 英寸)。 简而言之,安卓系统将所有屏幕尺寸简化为三大类:大、普通和小。 程序可以为这三种屏幕尺寸提供三种不同的布局选项,然后系统会以合适的方式将布局选项呈现到相应的屏幕上,这个过程不需要程序员用代码进行干预。 屏幕纵横比 屏幕的物理长度与物理宽度之比。程序只需使用系统提供的资源分类器 long(长)和 notlong(不长),就能为具有特定长宽比的屏幕提供配制材料。 分辨率 屏幕的像素总数。请注意,分辨率并不意味着长宽比,尽管在大多数情况下,分辨率表示为 "宽度 x 长度"。在安卓系统中,程序一般不直接处理分辨率。 密度 根据屏幕分辨率,沿屏幕宽度和长度排列的像素数量。 密度较低的屏幕在长度和宽度方向上的像素都相对较少,而密度较高的屏幕通常会在同一区域内排列很多甚至非常非常多的像素。屏幕的密度非常重要;例如,一个界面元素(如按钮)的长度和宽度以像素为单位,在低密度屏幕上会显得很大,但在高密度屏幕上就会显得很小。 独立于密度的像素(DIP)是指程序用来定义界面元素的抽象意义上的像素。它作为一个与实际密度无关的单位,帮助程序员构建布局方案(界面元素的宽度、高度和位置)。 与密度无关的像素在逻辑上与像素密度为 160 DPI 的屏幕上的像素大小相同,而 160 DPI 是安卓平台默认的显示设备。在运行时,平台会以目标屏幕的密度为基准,"透明 "地处理所有所需的 DIP 缩放操作。要将与密度无关的像素转换为屏幕像素,可以使用一个简单的公式:像素 = DIP * (密度 / 160)。例如,在 240 DPI 的屏幕上,1 个 DIP 等于 1.5 个物理像素。强烈建议使用 DIP 来定义程序界面的布局,因为这样可以确保用户界面在所有分辨率的屏幕上都能正常显示。 为了简化程序员在面对各种分辨率时的麻烦,也为了让各种分辨率的平台都能直接运行这些程序,Android 平台将所有屏幕以密度和分辨率作为分类方式,分别分为三类:- 三大尺寸:大、普通、小;- 三种不同密度:高(hdpi)、中(mdpi)和低(ldpi)。DPI 表示 "每英寸点数",即每英寸的像素数。如果需要,程序可以为不同的屏幕尺寸提供不同的资源(主要是布局),为不同的屏幕密度提供不同的资源(主要是位图)。除此之外,程序无需对屏幕尺寸或密度进行任何额外处理。执行时,平台会根据屏幕本身的尺寸和密度特性自动加载相应的资源,并将其从逻辑像素(DIP,用于定义界面布局)转换为屏幕上的物理像素。
-
PyTorch 的简单实现