目录
🌞一、实验目的
🌞二、实验准备
🌞三、实验内容
🌼1. 生成螺旋状数据集
🌼2. 打印数据集
🌼3. 编程实现
🌻仿射层-Affine类
🌻传播层-Sigmoid类
🌻损失函数相关类
🌻三层神经网络类-ThreeLayerNet
🌻随机梯度下降法的类-SGD
🌻训练过程
🌻绘制迭代效果图
🌞四、实验心得
🌞一、实验目的
- 利用神经网络识别螺旋状数据集(python实现);
- 正确理解深度学习所需的数学知识。
🌞二、实验准备
- 根据GPU安装pytorch版本实现GPU运行实验代码;
- 配置环境用来运行 Python、Jupyter Notebook和相关库等相关库。
🌞三、实验内容
资源获取:关注公众号【科创视野】回复 深度学习
🌼1. 生成螺旋状数据集
(1)利用numpy库生成螺旋状数据集,python源码如下:
# coding: utf-8
import numpy as np
def load_data(seed=2020264): #🍕🍕🍕生成数据集🍕🍕🍕
np.random.seed(seed) #设置随机数种子
N = 100 # 各类的样本数
DIM = 2 # 数据的元素个数
CLS_NUM = 3 # 类别数
x = np.zeros((N*CLS_NUM, DIM))
t = np.zeros((N*CLS_NUM, CLS_NUM), dtype=np.int)
for j in range(CLS_NUM):
for i in range(N):#N*j, N*(j+1)):
rate = i / N
radius = 1.0*rate
theta = j*4.0 + 4.0*rate + np.random.randn()*0.2
ix = N*j + i
x[ix] = np.array([radius*np.sin(theta),
radius*np.cos(theta)]).flatten()
t[ix, j] = 1
return x, t
解释:
1.代码中导入了numpy库,用于生成和处理数组。
2.load_data函数:该函数用于生成数据集。接受一个seed参数,用于设置随机数生成的种子,以确保结果的可重复性。
3.设置参数:在函数内部,定义了几个参数,包括样本数N、数据的元素个数DIM和类别数CLS_NUM。这些参数用于确定生成数据的规模和属性。
4.初始化数组:通过np.zeros函数创建了两个数组x和t,用于存储生成的样本和对应的标签。
5.数据生成循环:通过两个嵌套的循环,依次生成每个类别的样本。外层循环遍历类别数,内层循环生成每个类别中的样本。
6.样本生成:在内层循环中,首先根据当前类别和样本索引计算出一个比例rate,用于确定样本的半径。然后,根据一定的规则计算样本的极坐标位置(半径和角度),并引入一定的随机扰动。最后,将样本的极坐标位置转换为笛卡尔坐标位置,并存储在数组x中。
7.标签生成:在内层循环中,通过将当前样本所属类别对应的位置设为1,将标签存储在数组t中。
8.返回结果:最后,函数返回生成的样本数组x和标签数组t。
🌼2. 打印数据集
在加载完数据集后,利用plt将生成的数据集打印出来,python源码如下:
# coding: utf-8
import sys
sys.path.append('..') # 为了引入父目录的文件而进行的设定
import matplotlib.pyplot as plt
x, t = load_data()
print('x', x.shape) # (300, 2)
print('t', t.shape) # (300, 3)
# 绘制数据点
N = 100
CLS_NUM = 3
markers = ['o', 'x', '^']
for i in range(CLS_NUM):
plt.scatter(x[i*N:(i+1)*N, 0], x[i*N:(i+1)*N, 1], s=40, marker=markers[i])
plt.show()
解释:
1.导入sys和matplotlib.pyplot库。sys库用于在代码中添加父目录的路径,而matplotlib.pyplot库用于数据可视化。
2.添加父目录路径:通过sys.path.append('..')语句,将父目录路径添加到代码中。这样做是为了能够引入父目录中的文件,这里是为了引入之前定义的load_data()函数。
3.调用load_data()函数:通过调用load_data()函数,生成数据集的特征数组x和标签数组t。
4.打印数组形状:通过print()语句打印出数据集特征数组x和标签数组t的形状。x.shape输出的结果是(300, 2),表示x数组有300行和2列;t.shape输出的结果是(300, 3),表示t数组有300行和3列。这里的形状信息给出了生成数据集的维度信息。
5.绘制数据点:接下来,通过使用matplotlib.pyplot库来绘制数据集的散点图。循环遍历每个类别,利用plt.scatter()函数绘制对应类别的数据点。函数中的参数包括样本的x坐标和y坐标,使用不同的标记形状markers[i]和尺寸s=40来区分不同类别的数据点。
6.显示图像:最后,通过plt.show()函数显示绘制的图像,将数据集的散点图展示出来。
结果图为:
🌼3. 编程实现
🌻仿射层-Affine类
class Affine:
def __init__(self,W,b):
self.params = [W,b]#保存参数
self.grads = [np.zeros_like(W),np.zeros_like(b)]#保存梯度
self.x = None
def forward(self,x):
W,b = self.params
out = np.dot(x,W) + b
self.x = x
return out
def backward(self,dout):
W,b = self.params
dx = np.dot(dout,W.T)
dW = np.dot(self.x.T,dout)
db = np.sum(dout,axis=0)
self.grads[0][...] = dW
self.grads[1][...] = db
return dx
解释:
1.Affine类表示神经网络中的仿射层(Affine Layer)。类的初始化方法(__init__):该方法在创建Affine类的实例时被调用。它接受两个参数W和b,分别表示仿射层的权重和偏置。在方法中,首先创建了一个params列表,用于保存权重和偏置参数。然后创建了一个grads列表,用于保存权重和偏置参数的梯度。最后,初始化了一个x变量,并将其设为None。
2.前向传播方法(forward):该方法接受一个输入x,并根据保存的权重和偏置参数进行仿射变换。首先,从params列表中获取权重W和偏置b。然后,通过计算输入x与权重W的乘积,并加上偏置b,得到输出out。最后,将输入x保存在self.x变量中,并返回输出out。
3.反向传播方法(backward):该方法接受一个上游梯度dout,并根据保存的权重和输入x计算梯度。首先,从params列表中获取权重W和偏置b。然后,通过上游梯度dout与权重W的转置的乘积,得到对输入x的梯度dx。接下来,计算权重W的梯度dW,通过将输入x的转置与上游梯度dout的乘积得到。最后,计算偏置b的梯度db,通过对上游梯度dout按列求和得到。
4.更新梯度和返回梯度:在方法的最后,通过将权重和偏置的梯度分别赋值给self.grads列表中对应的元素,来更新梯度信息。使用[...]操作符可以确保在赋值时不改变梯度数组的形状和数据类型。最后返回输入的梯度dx,以便反向传播给前一层。
🌻传播层-Sigmoid类
class Sigmoid:
def __init__(self):
self.params = []
self.grads = []
self.out = None
def forward(self,x):
out = 1 / (1 + np.exp(-x))
self.out = out
return out
def backward(self,dout):
dx = dout * (1.0 - self.out) * self.out
return dx
解释:
1.Sigmoid类表示一个Sigmoid函数。类的初始化:在__init__方法中,定义了三个实例变量params、grads和out,分别用于存储参数、梯度和前向传播的输出结果。这些变量在类的实例化时被创建,并初始化为空。
2.前向传播:在forward方法中,接收输入x作为参数。通过应用Sigmoid函数的定义,计算出输出out,即 1 / (1 + np.exp(-x))。然后将计算结果赋值给实例变量self.out,以便在反向传播中使用,并返回输出out。
3.反向传播:在backward方法中,接收反向传播的上游梯度dout作为参数。通过应用Sigmoid函数的导数公式,计算出输入x的梯度dx,即 dout * (1.0 - self.out) * self.out。然后返回计算得到的梯度dx。
🌻损失函数相关类
def softmax(x):
if x.ndim == 1:
x = x - np.max(x)
x = np.exp(x)/np.sum(np.exp(x))
elif x.ndim == 2:
x = x - x.max(axis = 1,keepdims = True)
x = np.exp(x)
x /= x.sum(axis=1, keepdims=True)
return x
def cross_entropy_error(y,t):
if y.ndim == 1:
t = t.reshape(1,t.size)
y = y.reshape(1,y.size)
#因为监督标签是one-hot-vector形式,所以这里要取下标
if t.size == y.size:
t = t.argmax(dim=1)
batch_size = y.shape[0]
#没看懂为啥
return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size
class SoftmaxWithLoss:
def __init__(self):
self.params = []
self.grads = []
self.y = None #softmx的输出
self.t = None #监督标签
def forward(self,x,t):
self.t = t
self.y = softmax(x)
if self.t.size == self.y.size:
self.t = self.t.argmax(axis=1)
loss = cross_entropy_error(self.y,self.t)
return loss
def backward(self,dout =1):
batch_size = self.t.shape[0]
dx = self.y.copy()
dx[np.arange(batch_size),self.t] -= 1
dx *= dout
dx = dx/batch_size
return dx
解释:
1. softmax函数实现了Softmax函数的计算,接受一个数组x作为输入,根据输入的维度情况进行不同的计算。
当x的维度是1维时,首先将x减去最大值,然后计算每个元素的指数,并除以所有指数的和,得到Softmax函数的输出。
当x的维度是2维时,首先将x每行减去对应行的最大值,然后计算每个元素的指数,并除以每行指数的和,得到Softmax函数的输出。
最后,返回计算得到的Softmax函数的输出。
2. cross_entropy_error函数:实现交叉熵损失函数的计算。接受两个数组y和t作为输入,根据输入的维度情况进行不同的计算。
首先,根据输入的维度情况将t的形状调整为和y相同的形状,以便进行计算。
如果t的大小和y的大小相同,说明t是以one-hot向量形式表示的监督标签,这里将其转换为对应的类别索引。
接着,根据批量的大小计算交叉熵损失,通过对y使用np.arange(batch_size)和t的索引,取出正确类别的预测概率,并计算其对数,然后求和并取负数,最后除以批量大小得到平均损失。
最后,返回计算得到的交叉熵损失。
3. SoftmaxWithLoss类:这个类实现了Softmax with Loss层,包含了前向传播和反向传播的计算。
__init__方法用于初始化类的实例变量,包括参数列表params、梯度列表grads,以及用于保存Softmax函数的输出y和监督标签t的变量。
forward方法用于执行前向传播计算,接受输入x和监督标签t作为参数。在该方法中,首先将t赋值给实例变量self.t,然后使用softmax函数计算x的Softmax输出y。接着根据t的维度情况将t转换为类别索引形式。最后调用cross_entropy_error函数计算Softmax with Loss的损失并返回。
backward方法用于执行反向传播计算,接受一个可选的上游梯度dout作为参数,默认为1。在该方法中,首先获取监督标签的批量大小,然后创建一个梯度副本dx,并将其初始化为Softmax函数输出y的副本。接下来,根据监督标签的索引,在dx中将正确类别的位置减去1,以计算Softmax with Loss层的梯度。然后,将梯度乘以上游梯度dout,并除以批量大小,以获得平均梯度。最后,返回计算得到的梯度dx。
🌻三层神经网络类-ThreeLayerNet
class ThreeLayerNet:
def __init__(self,input_size,hidden_size1,hidden_size2,output_size):
I,H1,H2,O = input_size,hidden_size1,hidden_size2,output_size
#初始化权重和偏置
W1 = 0.01 * np.random.randn(I,H1) #形状:I*H
b1 = np.zeros(H1)
W2 = 0.01 * np.random.randn(H1,H2)
b2 = np.zeros(H2)
W3 = 0.01 * np.random.randn(H2,O)
b3 = np.zeros(O)
#生成层
self.layers = [
Affine(W1,b1),
Sigmoid(),
Affine(W2,b2),
Sigmoid(),
Affine(W3,b3)
]
#Softmax With Loss层和其他层的处理方式不同
#所以不将它放在layers列表中,而是单独存储在变量loss_layer中
self.loss_layer = SoftmaxWithLoss()
self.params,self.grads = [],[]
for layer in self.layers:
self.params += layer.params
self.grads += layer.grads
def predict(self,x):
for layer in self.layers:
x = layer.forward(x)
return x
def forward(self,x,t):
score = self.predict(x)
loss = self.loss_layer.forward(score,t)
return loss
def backward(self,dout = 1):
dout = self.loss_layer.backward(dout)
for layer in reversed(self.layers):
dout = layer.backward(dout)
return dout
解释:
1.这里我实现了一个三层神经网络的类ThreeLayerNet,该类包含了网络的初始化、前向传播、反向传播和预测等方法。在初始化方法__init__中,定义了神经网络的结构和初始化权重和偏置。input_size表示输入层的大小,hidden_size1和hidden_size2表示两个隐藏层的大小,output_size表示输出层的大小。
2.权重的初始化采用了高斯分布随机初始化,通过np.random.randn生成服从标准正态分布的随机数,并乘以0.01进行缩放。偏置初始化为全零向量。
3.下面生成了三个层的实例,并按照顺序存储在self.layers列表中,分别是全连接层(Affine)、激活函数层(Sigmoid)和输出层(Softmax With Loss)。为了方便参数更新,将各层的参数和梯度分别存储在self.params和self.grads列表中。
4.predict方法用于进行前向传播,通过遍历self.layers列表,依次调用每个层的前向传播方法forward,并将输出作为下一层的输入,最终返回最后一层的输出结果。
5.forward方法在进行预测的同时,计算了损失值。首先调用predict方法获取输出结果,然后将输出结果和目标值t传入损失层self.loss_layer的前向传播方法forward,计算得到损失值,并返回。
6.backward方法用于进行反向传播,接收一个梯度dout作为输入,该梯度的默认值为1。首先将梯度传递给损失层self.loss_layer的反向传播方法backward,得到更新后的梯度。然后按照相反的顺序遍历self.layers列表,依次调用每个层的反向传播方法backward,将更新后的梯度传递给前一层,最终返回最初输入层的梯度。
🌻随机梯度下降法的类-SGD
class SGD:
'''
随机梯度下降法(Stochastic Gradient Descent)
'''
def __init__(self, lr=0.01):
self.lr = lr
def update(self, params, grads):
for i in range(len(params)):
params[i] -= self.lr * grads[i]
解释:
1.这里我实现了随机梯度下降法(Stochastic Gradient Descent,SGD)的类SGD,用于更新神经网络的参数。在初始化方法__init__中,定义了学习率lr,默认值为0.01。学习率控制了每次参数更新的步长。
2.update方法接收两个参数:params是网络中的参数列表,grads是对应参数的梯度列表。该方法根据SGD的更新规则,对每个参数进行更新。
3.在循环中,遍历了参数列表params和梯度列表grads的索引。对于每个参数和对应的梯度,使用梯度乘以学习率的方式更新参数。这里采用了原地更新,即直接在参数列表中更新参数的值。
4.通过减去学习率乘以梯度,实现了参数的更新。
🌻训练过程
#1.设定超参数
max_epoch = 300
batch_size = 30
hidden_size = 10
learning_rate =3.5
#2.读入数据,生成模型和优化器
x,t = load_data()
model = ThreeLayerNet(input_size=2,hidden_size1=hidden_size,hidden_size2=hidden_size,output_size=3)
optimizer = SGD(lr=learning_rate)
#学习用的变量
data_size = len(x)
max_iters = data_size // batch_size
total_loss = 0
loss_count = 0
loss_list = []
for epoch in range(max_epoch):
#3.打乱数据
idx = np.random.permutation(data_size)
x = x[idx]
t = t[idx]
for iters in range(max_iters):
batch_x = x[iters*batch_size:(iters+1)*batch_size]
batch_t = t[iters*batch_size:(iters+1)*batch_size]
#4.计算梯度,更新参数
loss = model.forward(batch_x,batch_t)
model.backward()
optimizer.update(model.params,model.grads)
total_loss += loss
loss_count += 1
#5.定期输出学习过程
if (iters+1)%10 == 0:
avg_loss = total_loss / loss_count
print('| epoch %d | iterations %d / %d | loss %0.2f'% (epoch+1,iters + 1,max_iters,avg_loss))
loss_list.append(avg_loss)
total_loss,loss_count = 0,0
解释:
1.这里我实现了一个训练过程的循环,其中包含了数据处理、模型的前向传播、反向传播以及参数更新的步骤。首先,在代码中设定了一些超参数,包括最大迭代次数max_epoch、批大小batch_size、隐藏层大小hidden_size和学习率learning_rate。接下来,通过调用load_data函数读取数据,然后创建了一个ThreeLayerNet类的实例model,指定了输入层大小为2、两个隐藏层大小为hidden_size、输出层大小为3的网络结构。同时,创建了一个SGD类的实例optimizer,传入学习率learning_rate。接着,初始化了一些用于学习过程的变量,包括数据集大小data_size、每个迭代中的最大批次数max_iters、总损失total_loss、损失计数loss_count和损失列表loss_list。
2.下面是主要的训练循环,通过max_epoch控制迭代次数。在每个迭代中,首先进行数据的打乱操作,使用np.random.permutation对数据索引进行随机排列,然后根据打乱后的索引重新排列输入数据x和目标数据t,实现数据的随机化。然后,在每个迭代中,根据最大批次数max_iters遍历数据集。每次迭代从数据集中选取一批数据,包括输入数据batch_x和目标数据batch_t,并进行以下步骤:
调用模型的forward方法,计算当前批次的损失值,并返回该损失值。
调用模型的backward方法,根据损失值进行反向传播,计算参数的梯度。
调用优化器的update方法,根据梯度更新模型的参数。
3.累计当前批次的损失值到total_loss中,并增加loss_count计数器。如果当前批次的迭代次数是10的倍数,输出当前迭代的平均损失值,并将其添加到loss_list列表中。将total_loss和loss_count重置为0,为下一个迭代做准备。
训练循环的目的是通过多次迭代和参数更新,逐渐减小损失值,使模型适应训练数据,实现模型的训练过程。输出的学习过程中的损失值可以用于监控训练的进展。
运行迭代300次的结果图如下:
x, t = load_data()
# 绘制数据点
N = 100
CLS_NUM = 3
markers = ['o', 'x', '^']
# 绘制决策边界
h = 0.001
x_min, x_max = x[:, 0].min() - .1, x[:, 0].max() + .1
y_min, y_max = x[:, 1].min() - .1, x[:, 1].max() + .1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
X = np.c_[xx.ravel(), yy.ravel()]
score = model.predict(X)
predict_cls = np.argmax(score, axis=1)
Z = predict_cls.reshape(xx.shape)
plt.contourf(xx, yy, Z)
for i in range(CLS_NUM):
plt.scatter(x[i*N:(i+1)*N, 0], x[i*N:(i+1)*N, 1], s=40, marker=markers[i])
plt.axis('off') # 是否关闭坐标轴
plt.show()
解释:
1.这里用于绘制数据点和模型的决策边界。首先,调用load_data函数加载数据,并将输入数据赋值给变量x,目标数据赋值给变量t。接着,定义了一些用于绘制的参数。N表示每个类别的数据点数量,CLS_NUM表示类别的数量,markers是绘制数据点时使用的标记符号。然后,通过指定步长h和输入数据的范围,创建了一个网格xx和yy,用于在整个输入空间上生成一组点。这些点将用于计算模型的预测结果,并绘制决策边界。
2.通过调用模型的predict方法,对生成的点进行预测。X是一个二维数组,每一行表示一个点的坐标。将这些点作为输入,得到模型的预测结果score,其中score是一个二维数组,表示每个点属于不同类别的概率。
3.使用np.argmax函数找到每个点概率最大的类别索引,得到预测的类别标签predict_cls。然后将predict_cls重新调整为与网格一样的形状,得到二维数组Z,用于绘制决策边界。
4.使用plt.contourf函数绘制决策边界,通过填充不同区域的颜色来表示不同的类别。
5.接下来,使用循环遍历每个类别,并使用plt.scatter函数绘制每个类别的数据点。通过切片操作x[i*N:(i+1)*N, 0]和x[i*N:(i+1)*N, 1],选择属于当前类别的数据点的坐标,并使用对应的标记符号进行绘制。
6.最后,通过plt.axis('off')设置是否关闭坐标轴,并调用plt.show()显示绘制的图像。
由此产生的图像可以看到相较于两层神经网络的效果更好,三层神经网络的结果如下所示:
🌻绘制迭代效果图
# loss_list----记录300次迭代次数
import numpy as np
import matplotlib.pyplot as plt
#正确显示中文和负号
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False
# 数据准备
x3=range(1,301)
y3=loss_list
# 设置画布大小
plt.figure(figsize=(12, 5))
# plot 画x与y和x与z的关系图
plt.plot(x3,y3,label='损失函数',color='#1F77B4', linewidth=1,marker='',markersize=3)
# 设置x轴标签、坐标轴范围,坐标轴刻度,坐标轴刻度旋转角度
plt.xlabel('iterations(x10)',size=14)
plt.xlim(0,300)
plt.xticks([0,50,100,150,200,250,300],rotation=0,size=12) #
# 设置y轴标签、坐标轴范围,坐标轴刻度,坐标轴刻度旋转角度
plt.ylabel('loss',size=14)
plt.ylim(0,1.2)
plt.yticks([0,0.2,0.4,0.6,0.8,1.0,1.2],rotation=0,size=12)
#标题
plt.title('损失函数',size=18)
# 紧凑布局:自动调整图形、坐标轴、标签之间的距离,对于多个子图时尤其有用。
plt.tight_layout()
# 设置显示图例,要在plt.plot 时设置 label='xxx'才能显示图例
plt.legend()
#加网格线
plt.grid(True)
# 保存图像,可以是任意后缀名,dpi设置图像清晰度
#plt.savefig('./fig1.pdf', dpi=600) #要放在plt.show()之前,否作保存的图像为空白
# 显示图像
plt.show()
解释:
1.设置中文和负号显示:通过设置plt.rcParams['font.sans-serif']=['SimHei']和plt.rcParams['axes.unicode_minus']=False来确保图表中的中文和负号能够正确显示。
2.数据准备:定义了一个x轴的范围从1到300,以及一个y轴的数据列表loss_list,用于记录300次迭代的损失函数值。
3.设置画布大小:通过plt.figure(figsize=(12, 5))设置绘图画布的大小为宽度12英寸、高度5英寸。
4.绘制曲线:使用plt.plot(x3, y3, label='损失函数', color='#1F77B4', linewidth=1, marker='', markersize=3)绘制曲线,x轴为迭代次数,y轴为损失函数值。label='损失函数'用于在图例中显示曲线的标签,color='#1F77B4'设置曲线的颜色,linewidth=1设置曲线的线宽,marker=''表示不显示数据点的标记,markersize=3设置数据点的大小。
5.设置坐标轴和刻度:使用plt.xlabel('iterations(x10)', size=14)设置x轴的标签为'iterations(x10)',plt.xlim(0, 300)设置x轴的范围为0到300,plt.xticks([0,50,100,150,200,250,300],rotation=0,size=12)设置x轴的刻度为[0, 50, 100, 150, 200, 250, 300],rotation=0表示刻度标签不旋转,size=12表示刻度标签的字体大小。
6.设置y轴的标签和刻度同理。设置标题:使用plt.title('损失函数', size=18)设置图表的标题为'损失函数',size=18表示标题的字体大小。
7.调整布局:使用plt.tight_layout()自动调整图形、坐标轴、标签之间的距离,使其紧凑显示。
8.显示图例:使用plt.legend()显示图例,前提是在绘制曲线时设置了label='损失函数'。添加网格线:使用plt.grid(True)添加网格线。
实验结果如下:
🌞四、实验心得
通过这次实验,我成功创建了一个用于识别螺旋状的数据集三层神经网络,并对深度学习所需的数学知识有了更深入的理解。
一开始,我选择了ReLU激活函数,但是在调整学习率时无法找到合适的参数。因此改用Sigmoid作为激活函数。通过建立三层神经网络,我发现之前适用于两层神经网络的学习率并不适用于三层神经网络,需要重新寻找适合的学习率,而学习率设置得太小会导致学习的收敛速度变慢。
通过对比两层和三层神经网络的训练结果,我发现它们之间存在明显的差异,特别是在中心点区域。这说明增加网络的层数可以更好地拟合复杂的数据集,但也需要仔细调整参数以确保网络的有效训练。
两层神经网络结果:
三层神经网络结果: