前馈神经网络实验

这篇具有很好参考价值的文章主要介绍了前馈神经网络实验。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  1. 手动实现前馈神经网络解决回归、二分类、多分类任务,分析实验结果并绘制训练集和测试集的loss曲线;
  2. 利用torch.nn实现前馈神经网络解决上述回归、二分类、多分类任务,分析实验结果并绘制训练集和测试集的loss曲线;
  3. 在多分类实验的基础上使用至少三种不同的激活函数,对比使用不同激活函数的实验结果;
  4. 对多分类任务中的模型,评估隐藏层层数和隐藏单元个数对实验结果的影响使用不同的隐藏层层数和隐藏单元个数,进行对比实验并分析实验结果;
  5. 在多分类任务实验中分别手动实现和用torch.nn实现dropout,探究不同丢弃率对实验结果的影响(可用loss曲线进行展示);
  6. 在多分类任务实验中分别手动实现和用torch.nn实现L2正则化,探究惩罚项的权重对实验结果的影响(可用loss曲线进行展示);
  7. 对回归、二分类、多分类任务分别选择上述实验中效果最好的模型,采用10折交叉验证评估实验结果,要求除了最终结果外还需以表格的形式展示每折的实验结果;

本次实验所使用的是在Pycharm 环境下安装的Python 3.9.7版本以及Pytorch 1.10。

1)回归任务的数据集

回归任务为是单个数据集,数据集的大小为10000且训练集大小为7000,测试集大小为3000。数据集的样本特征维度p为500,且服从如下的高维线性函数。

import torch
import numpy as np

num_inputs = 500
num_examples = 10000
x_features = torch.tensor(np.random.normal(0, 1, (num_examples, num_inputs)), dtype=torch.float)
y_labels = torch.mm(x_features,torch.ones(500,1)*0.0056) + 0.028
y_labels += torch.tensor(np.random.normal(0, 0.01, size=y_labels.size()), dtype=torch.float)
#训练集
trainfeatures =x_features[:7000]
trainlabels = y_labels[:7000]
#测试集
testfeatures =x_features[7000:]
testlabels = y_labels[7000:]

2)二分类任务的数据集

二分类任务的数据集由两个数据集构成,两个数据集的大小均为10000且训练集大小为7000,测试集大小为3000。两个数据集的样本特征x的维度均为200,且分别服从均值互为相反数且方差相同的正态分布。两个数据集的样本标签分别为0和1。通过键入下面代码,构造该数据集。

import torch
from matplotlib import pyplot as plt

num_inputs = 200
#1类
x1 = torch.normal(1,1,(10000, num_inputs))
y1 = torch.ones(10000,1)
x1_train = x1[:7000]
x1_test  = x1[7000:]
#0类
x2 = torch.normal(-1,1,(10000, num_inputs))
y2 = torch.zeros(10000,1)
x2_train = x2[:7000]
x2_test  = x2[7000:]

# 合并训练集
train_features = torch.cat((x1_train,x2_train), 0).type(torch.FloatTensor)
train_labels   = torch.cat((y1[:7000], y2[:7000]), 0).type(torch.FloatTensor)
# 合并测试集
test_features = torch.cat((x1_test,x2_test), 0).type(torch.FloatTensor)
test_labels   = torch.cat((y1[7000:], y2[7000:]), 0).type(torch.FloatTensor)

plt.scatter(train_features.data.numpy()[:, 0], train_features.data.numpy()[:, 1], c=train_labels.data.numpy(), s=100, lw=0, cmap='RdYlGn')
plt.show()

3)多分类数据集

多分类数据集为MNIST手写体数据集,该数据集包含60000个用于训练的图像样本和10000个用于测试的图像样本。图像是固定大小(28×28像素),其值为0到1。为每个图像都被平展并转换为784个特征的一维numpy数组。通过键入下面代码,下载MNIST手写体数据集。

import torch                                            #导入pytorch框架
import torchvision
import torchvision.transforms as transforms

## 生成数据
# 获取FashionMNIST数据集,将所有数据转化为Tensor
mnist_train = torchvision.datasets.MNIST(root='~/Datasets/MNIST',
                                         train=True, download=True, transform=transforms.ToTensor())
mnist_test  = torchvision.datasets.MNIST(root='~/Datasets/MNIST',
                                         train=False, transform=transforms.ToTensor())

# 通过DataLoader 读取小批量数据样本
batch_size = 128
train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True,num_workers=0)
test_iter  = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False,num_workers=0)

1、手动实现前馈神经网络解决回归、二分类、多分类任务,分析实验结果并绘制训练集和测试集的loss曲线

(1)回归

## 导入实验所需的包
import numpy as np
import torch
from torch.utils import data
from matplotlib import pyplot as plt

## 第一部分:构建回归任务数据集
n_train, n_test, num_inputs = 7000,3000,500
true_w, true_b = torch.ones(num_inputs, 1), 0.028         #添加噪声项和b
features=torch.randn((n_train+ n_test, num_inputs))
labels = torch.matmul(features, true_w) + true_b
labels+=torch.tensor(np.random.normal(0,0.01, size=labels.size()))
train_features,test_features = features[:n_train, :], features[n_train:, :]
train_labels, test_labels = labels[:n_train], labels[n_train:, :]
print(train_features.shape) # 看看维数对不对
print(test_features.shape)  # 看看维数对不对

## 第二部分:定义数据迭代器
dataset_train = data.TensorDataset(train_features, train_labels)
dataset_test  = data.TensorDataset(test_features , test_labels )
batch_size    = 50
train_iter    = data.DataLoader(dataset=dataset_train, batch_size=batch_size, shuffle=True, num_workers=0)
test_iter     = data.DataLoader(dataset=dataset_test , batch_size=batch_size, shuffle=True, num_workers=0)

## 第三部分:定义模型及其前向传播过程
class Net():
    def __init__(self):
        # 定义并初始化模型参数
        num_inputs, num_outputs, num_hiddens = 500,1,256
        W1 = torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_inputs)), dtype=torch.float32)
        b1 = torch.zeros (1, dtype=torch.float32)
        W2 = torch.tensor(np.random.normal(0, 0.01, (num_outputs, num_hiddens)), dtype=torch.float32)
        b2 = torch.zeros (1, dtype=torch.float32)
        # 上述四个变量求梯度
        self.params = [W1, b1, W2, b2]
        for param in self.params:
            param.requires_grad_(requires_grad = True)
        # 定义模型的结构
        self.inputs_layer  = lambda x: x.view(x.shape[0],-1)
        self.hiddens_layer = lambda x: self.my_ReLU(torch.matmul(x, W1.t())+ b1)
        self.outputs_layer  = lambda x: torch.matmul(x, W2.t())+ b2
    @staticmethod
    def my_ReLU(x):
        return torch.max(input=x,other=torch.tensor(0.0))
    def forward(self, x):
        flatten_input = self.inputs_layer(x)
        hidden_output = self.hiddens_layer(flatten_input)
        final_output  = self.outputs_layer(hidden_output)
        return final_output

## 第四部分:定义损失函数及优化算法
loss_func = torch.nn.MSELoss()
def SGD (params,lr):
    for param in params:
        param.data-=lr*param.grad

## 第五部分:定义测试函数
def test(data_iter,net,loss_func) :
    test_loss_sum,c = 0.0,0
    for X, y in data_iter:
        result = net.forward(X)
        test_loss_sum+= loss_func(result, y).item()
        c +=1
    return test_loss_sum/c

## 第六部分:定义模型训练函数
def train(net, train_iter,loss_func, num_epochs,batch_size,lr=None,optimizer=None):
    train_loss_list = []
    test_loss_list  = []
    for epoch in range(num_epochs):
        train_l_sum,train_acc_sum,n,c = 0.0,0.0,0,0
        for X,y in train_iter: # x和y分别是小批量样本的特征和标签
            y_hat = net.forward(X)
            l=loss_func(y_hat,y)
            l.backward()
            optimizer(net.params, lr)
            for param in net.params:
                param.grad.data.zero_()
            train_l_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
            c += 1
        test_loss = test(test_iter,net,loss_func)
        train_loss_list.append(train_l_sum/c)
        test_loss_list.append(test_loss)
        # draw_loss(train_l_sum/c, test_loss, None)
        print('epoch %d, train_loss %.4f,test_loss %.4f'%(epoch+1, train_l_sum/c,test_loss))
    return train_loss_list,test_loss_list


## 第七部分:结果可视化
def draw_loss(train_loss, test_loss,valid_loss=None):
    x = np.linspace(0,len(train_loss),len(train_loss))\
        if valid_loss is None else np.linspace(0,len(train_loss),len(test_loss),len(valid_loss))
    plt.plot(x,train_loss,label="Train_Loss",linewidth=1.5)
    plt.plot(x,test_loss,label="Test_Loss",linewidth=1.5)
    if valid_loss is not None:
        plt.plot(x,test_loss,label="Valid_loss",linewidth=1.5)
    plt.xlabel("Epoch")
    plt.ylabel("Loss")
    plt.legend()
    plt.show()

## 第八部分:训练模型
net=Net()
num_epochs=100
lr = 0.003
optimizer=SGD
train_loss,test_loss = train(net, train_iter,loss_func,num_epochs,batch_size,lr,optimizer)
draw_loss(train_loss,test_loss)

(2)二分类

## 导入实验所需的包
import numpy as np
import torch
from torch.utils import data
from matplotlib import pyplot as plt

## 第一部分:构建二分类任务数据集
n_train, n_test, num_inputs = 7000,3000,200
# 数据集1:样本标签为0
x0 = torch.normal(1,1,(n_train+ n_test, num_inputs))
y0 = torch.zeros(n_train+ n_test,1)
# 数据集2:样本标签为1
x1 = torch.normal(-1,1,(n_train+ n_test, num_inputs))
y1 = torch.ones(n_train+ n_test,1)
# torch.cat合并数据集
train_features = torch.cat((x0[:n_train], x1[:n_train]), 0).type(torch.FloatTensor)
train_labels   = torch.cat((y0[:n_train], y1[:n_train]), 0).type(torch.FloatTensor)
test_features  = torch.cat((x0[n_train:], x1[n_train:]), 0).type(torch.FloatTensor)
test_labels    = torch.cat((y0[n_train:], y1[n_train:]), 0).type(torch.FloatTensor)
print(train_features.shape,train_labels.shape,test_features.shape,test_labels.shape)

## 第二部分:定义数据迭代器
dataset_train = data.TensorDataset(train_features, train_labels)
dataset_test  = data.TensorDataset(test_features , test_labels )
batch_size    = 50
train_iter    = data.DataLoader(dataset=dataset_train, batch_size=batch_size, shuffle=True, num_workers=0)
test_iter     = data.DataLoader(dataset=dataset_test , batch_size=batch_size, shuffle=True, num_workers=0)

## 第三部分:定义模型及其前向传播过程
class Net():
    def __init__(self):
        # 定义并初始化模型参数
        num_inputs, num_outputs, num_hiddens = 200,1,256
        W1 = torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_inputs)), dtype=torch.float32)
        b1 = torch.zeros (1, dtype=torch.float32)
        W2 = torch.tensor(np.random.normal(0, 0.01, (num_outputs, num_hiddens)), dtype=torch.float32)
        b2 = torch.zeros (1, dtype=torch.float32)
        # 上述四个变量求梯度
        self.params = [W1, b1, W2, b2]
        for param in self.params:
            param.requires_grad_(requires_grad = True)
        # 定义模型的结构
        self.inputs_layer  = lambda x: x.view(x.shape[0],-1)
        self.hiddens_layer = lambda x: self.my_ReLU(torch.matmul(x, W1.t())+ b1)
        self.outputs_layer  = lambda x: torch.matmul(x, W2.t())+ b2
    @staticmethod
    def my_ReLU(x):
        return torch.max(input=x,other=torch.tensor(0.0))
    def forward(self, x):
        flatten_input = self.inputs_layer(x)
        hidden_output = self.hiddens_layer(flatten_input)
        final_output  = self.outputs_layer(hidden_output)
        return final_output

## 第四部分:定义损失函数及优化算法
loss_func = torch.nn.BCEWithLogitsLoss()
def SGD (params,lr):
    for param in params:
        param.data-=lr*param.grad

## 第五部分:定义测试函数
def test(data_iter,net,loss_func) :
    test_loss_sum,c = 0.0,0
    for X, y in data_iter:
        result = net.forward(X)
        test_loss_sum+= loss_func(result, y).item()
        c +=1
    return test_loss_sum/c

## 第六部分:定义模型训练函数
def train(net, train_iter,loss_func, num_epochs,batch_size,lr=None,optimizer=None):
    train_loss_list = []
    test_loss_list  = []
    for epoch in range(num_epochs):
        train_l_sum,train_acc_sum,n,c = 0.0,0.0,0,0
        for X,y in train_iter: # x和y分别是小批量样本的特征和标签
            y_hat = net.forward(X)
            l=loss_func(y_hat,y)
            l.backward()
            optimizer(net.params, lr)
            for param in net.params:
                param.grad.data.zero_()
            train_l_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
            c += 1
        test_loss = test(test_iter, net,loss_func)
        train_loss_list.append(train_l_sum/c)
        test_loss_list.append(test_loss)
        # draw_loss(train_l_sum/c, test_loss, None)
        print('epoch %d, train_loss %.4f,test_loss %.4f'%(epoch+1, train_l_sum/c,test_loss))
    return train_loss_list,test_loss_list

## 第七部分:结果可视化
def draw_loss(train_loss, test_loss,valid_loss=None):
    x = np.linspace(0,len(train_loss),len(train_loss))\
        if valid_loss is None else np.linspace(0,len(train_loss),len(test_loss),len(valid_loss))
    plt.plot(x,train_loss,label="Train_Loss",linewidth=1.5)
    plt.plot(x,test_loss,label="Test_Loss",linewidth=1.5)
    if valid_loss is not None:
        plt.plot(x,test_loss,label="Valid_loss",linewidth=1.5)
    plt.xlabel("Epoch")
    plt.ylabel("Loss")
    plt.legend()
    plt.show()

## 第八部分:训练模型
net=Net()
num_epochs=100
lr = 0.003
optimizer=SGD
train_loss,test_loss = train(net, train_iter,loss_func,num_epochs,batch_size,lr,optimizer)
draw_loss(train_loss,test_loss)

(3)多分类

## 导入实验所需的包
import numpy as np
import torch
from torch.utils import data
from matplotlib import pyplot as plt
import torchvision
import torchvision.transforms as transforms

## 第一部分:构建二分类任务数据集
mnist_train = torchvision.datasets.MNIST(root='~/Datasets/MNIST',train=True, download=True, transform=transforms.ToTensor())
mnist_test  = torchvision.datasets.MNIST(root='~/Datasets/MNIST',train=False, transform=transforms.ToTensor())

## 第二部分:定义数据迭代器
# 通过DataLoader 读取小批量数据样本
batch_size = 128
train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True,num_workers=0)
test_iter  = torch.utils.data.DataLoader(mnist_test,  batch_size=batch_size, shuffle=False,num_workers=0)

## 第三部分:定义模型及其前向传播过程
class Net():
    def __init__(self):
        # 定义并初始化模型参数
        num_inputs, num_outputs, num_hiddens = 784,10,256
        W1 = torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_inputs)), dtype=torch.float32)
        b1 = torch.zeros (1, dtype=torch.float32)
        W2 = torch.tensor(np.random.normal(0, 0.01, (num_outputs, num_hiddens)), dtype=torch.float32)
        b2 = torch.zeros (1, dtype=torch.float32)
        # 上述四个变量求梯度
        self.params = [W1, b1, W2, b2]
        for param in self.params:
            param.requires_grad_(requires_grad = True)
        # 定义模型的结构
        self.inputs_layer  = lambda x: x.view(x.shape[0],-1)
        self.hiddens_layer = lambda x: self.my_ReLU(torch.matmul(x, W1.t())+ b1)
        self.outputs_layer = lambda x: torch.matmul(x, W2.t())+ b2
    @staticmethod
    def my_ReLU(x):
        return torch.max(input=x,other=torch.tensor(0.0))
    def forward(self, x):
        flatten_input = self.inputs_layer(x)
        hidden_output = self.hiddens_layer(flatten_input)
        final_output  = self.outputs_layer(hidden_output)
        return final_output

## 第四部分:定义损失函数及优化算法
loss_func = torch.nn.CrossEntropyLoss()
def SGD (params,lr):
    for param in params:
        param.data-=lr*param.grad

## 第五部分:定义测试函数
def test(data_iter,net,loss_func) :
    test_loss_sum,c = 0.0,0
    for X, y in data_iter:
        result = net.forward(X)
        test_loss_sum+= loss_func(result, y).item()
        c +=1
    return test_loss_sum/c

## 第六部分:定义模型训练函数
def train(net,train_iter,loss_func, num_epochs,batch_size,lr=None,optimizer=None):
    train_loss_list = []
    test_loss_list  = []
    for epoch in range(num_epochs):
        train_l_sum,train_acc_sum,n,c = 0.0,0.0,0,0
        for X,y in train_iter: # x和y分别是小批量样本的特征和标签
            y_hat = net.forward(X)
            l=loss_func(y_hat,y)
            l.backward()
            optimizer(net.params, lr)
            for param in net.params:
                param.grad.data.zero_()
            train_l_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
            c += 1
        test_loss = test(test_iter, net,loss_func)
        train_loss_list.append(train_l_sum/c)
        test_loss_list.append(test_loss)
        # draw_loss(train_l_sum/c, test_loss, None)
        print('epoch %d, train_loss %.4f,test_loss %.4f'%(epoch+1, train_l_sum/c,test_loss))
    return train_loss_list,test_loss_list

## 第七部分:结果可视化
def draw_loss(train_loss, test_loss,valid_loss=None):
    x = np.linspace(0,len(train_loss),len(train_loss))\
        if valid_loss is None else np.linspace(0,len(train_loss),len(test_loss),len(valid_loss))
    plt.plot(x,train_loss,label="Train_Loss",linewidth=1.5)
    plt.plot(x,test_loss,label="Test_Loss",linewidth=1.5)
    if valid_loss is not None:
        plt.plot(x,test_loss,label="Valid_loss",linewidth=1.5)
    plt.xlabel("Epoch")
    plt.ylabel("Loss")
    plt.legend()
    plt.show()

## 第八部分:训练模型
net=Net()
num_epochs=100
lr = 0.03
optimizer=SGD
train_loss,test_loss = train(net,train_iter,loss_func,num_epochs,batch_size,lr,optimizer)
draw_loss(train_loss,test_loss)

代码实在是太多了,具体代码见:🍞正在装饰个人主页...文章来源地址https://www.toymoban.com/news/detail-611196.html

到了这里,关于前馈神经网络实验的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 前馈神经网络实验

    手动实现前馈神经网络解决回归、二分类、多分类任务,分析实验结果并绘制训练集和测试集的loss曲线; 利用torch.nn实现前馈神经网络解决上述回归、二分类、多分类任务,分析实验结果并绘制训练集和测试集的loss曲线; 在多分类实验的基础上使用至少三种不同的激活函数

    2024年02月15日
    浏览(37)
  • 深度学习实验3 - 卷积神经网络

    手写二维卷积的实现,并在至少一个数据集上进行实验,从训练时间、预测精度、Loss变化等角度分析实验结果(最好使用图表展示) 使用torch.nn实现二维卷积,并在至少一个数据集上进行实验,从训练时间、预测精度、Loss变化等角度分析实验结果(最好使用图表展示) 不同

    2024年02月14日
    浏览(49)
  • 【深度学习】实验05 构造神经网络示例

    神经网络是一种仿生学原理的机器学习算法,灵感来源于人脑的神经系统。它由多个神经元(或称为节点)组成,这些神经元通过连接权重形成复杂的网络结构,用来学习和提取输入数据的特征,并用于分类、回归、聚类等任务。 注明:该代码用来训练一个神经网络,网络拟

    2024年02月10日
    浏览(44)
  • 深度学习课程实验二深层神经网络搭建及优化

    1、学会训练和搭建深层神经网络; 2、掌握超参数调试正则化及优化。 初始化 1、导入所需要的库 2、搭建神经网络模型 3、零初始化 4、随机初始化 5、He初始化 6、总结三种不同类型的初始化 正则化 1、导入所需要的库 2、使用非正则化模型 3、对模型进行L2正则化(包括正向

    2024年01月24日
    浏览(39)
  • 【深度学习实验】循环神经网络(四):基于 LSTM 的语言模型训练

    目录 一、实验介绍 二、实验环境 1. 配置虚拟环境 2. 库版本介绍 三、实验内容 0. 导入必要的工具包 1. RNN与梯度裁剪 2. LSTM模型 3. 训练函数 a. train_epoch b. train 4. 文本预测 5. GPU判断函数 6. 训练与测试 7. 代码整合         经验是智慧之父,记忆是智慧之母。 ——谚语    

    2024年02月07日
    浏览(48)
  • 卷积神经网络与前馈神经网络

    常见的人工神经网络结构 人工神经网络是一类由人工神经元组成的网络,常见的神经网络结构包括: 前馈神经网络(Feedforward Neural Network,FNN):最简单的神经网络结构,由一个输入层、一个输出层和若干个隐藏层组成,信号只能从输入层流向输出层,不允许在网络中形成回

    2023年04月26日
    浏览(44)
  • 前馈神经网络多分类任务

    pytorch深度学习的套路都差不多,多看多想多写多测试,自然就会了。主要的技术还是在于背后的数学思想和数学逻辑。 废话不多说,上代码自己看。

    2024年02月12日
    浏览(45)
  • 前馈神经网络正则化例子

    直接看代码: 运行结果: 疑问和心得: 画图的实现和细节还是有些模糊。 正则化系数一般是一个可以根据算法有一定变动的常数。 前馈神经网络中,二分类最后使用logistic函数返回,多分类一般返回softmax值,若是一般的回归任务,一般是直接relu返回。 前馈神经网络的实现

    2024年02月12日
    浏览(50)
  • 重构Transformer神经网络:优化的自注意力机制和前馈神经网络

    标题:重构Transformer神经网络:优化的自注意力机制和前馈神经网络 摘要: 本论文研究了一种改进的Transformer神经网络模型,该模型使用区别于传统自注意力机制的新型注意力机制,以及优化的前馈神经网络。而且,该模型还引入了非线性激活函数以增强模型的表现力。实验

    2024年02月07日
    浏览(46)
  • 前馈神经网络解密:深入理解人工智能的基石

    本文深入探讨了前馈神经网络(FNN)的核心原理、结构、训练方法和先进变体。通过Python和PyTorch的实战演示,揭示了FNN的多样化应用。 作者TechLead,拥有10+年互联网服务架构、AI产品研发经验、团队管理经验,同济本复旦硕,复旦机器人智能实验室成员,阿里云认证的资深架

    2024年02月11日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包