人工智能-作业3：例题程序复现 PyTorch版

最新推荐文章于 2023-12-17 08:25:59 发布
最新推荐文章于 2023-12-17 08:25:59 发布
阅读量157 收藏
点赞数 1
分类专栏： 人工智能 文章标签： pytorch 人工智能 深度学习 神经网络 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49868511/article/details/124649926
版权

1.使用pytorch复现课上例题

import torch

x1, x2 = torch.Tensor([0.5]), torch.Tensor([0.3])
y1, y2 = torch.Tensor([0.23]), torch.Tensor([-0.07])
print("=====输入值：x1, x2；真实输出值：y1, y2=====")
print(x1, x2, y1, y2)
w1, w2, w3, w4, w5, w6, w7, w8 = torch.Tensor([0.2]), torch.Tensor([-0.4]), torch.Tensor([0.5]), torch.Tensor(
    [0.6]), torch.Tensor([0.1]), torch.Tensor([-0.5]), torch.Tensor([-0.3]), torch.Tensor([0.8])  # 权重初始值
w1.requires_grad = True
w2.requires_grad = True
w3.requires_grad = True
w4.requires_grad = True
w5.requires_grad = True
w6.requires_grad = True
w7.requires_grad = True
w8.requires_grad = True


def sigmoid(z):
    a = 1 / (1 + torch.exp(-z))
    return a


def forward_propagate(x1, x2):
    in_h1 = w1 * x1 + w3 * x2
    out_h1 = sigmoid(in_h1)  # out_h1 = torch.sigmoid(in_h1)
    in_h2 = w2 * x1 + w4 * x2
    out_h2 = sigmoid(in_h2)  # out_h2 = torch.sigmoid(in_h2)

    in_o1 = w5 * out_h1 + w7 * out_h2
    out_o1 = sigmoid(in_o1)  # out_o1 = torch.sigmoid(in_o1)
    in_o2 = w6 * out_h1 + w8 * out_h2
    out_o2 = sigmoid(in_o2)  # out_o2 = torch.sigmoid(in_o2)

    print("正向计算：o1 ,o2")
    print(out_o1.data, out_o2.data)

    return out_o1, out_o2


def loss_fuction(x1, x2, y1, y2):  # 损失函数
    y1_pred, y2_pred = forward_propagate(x1, x2)  # 前向传播
    loss = (1 / 2) * (y1_pred - y1) ** 2 + (1 / 2) * (y2_pred - y2) ** 2  # 考虑 ： t.nn.MSELoss()
    print("损失函数（均方误差）：", loss.item())
    return loss


def update_w(w1, w2, w3, w4, w5, w6, w7, w8):
    # 步长
    step = 1
    w1.data = w1.data - step * w1.grad.data
    w2.data = w2.data - step * w2.grad.data
    w3.data = w3.data - step * w3.grad.data
    w4.data = w4.data - step * w4.grad.data
    w5.data = w5.data - step * w5.grad.data
    w6.data = w6.data - step * w6.grad.data
    w7.data = w7.data - step * w7.grad.data
    w8.data = w8.data - step * w8.grad.data
    w1.grad.data.zero_()  # 注意：将w中所有梯度清零
    w2.grad.data.zero_()
    w3.grad.data.zero_()
    w4.grad.data.zero_()
    w5.grad.data.zero_()
    w6.grad.data.zero_()
    w7.grad.data.zero_()
    w8.grad.data.zero_()
    return w1, w2, w3, w4, w5, w6, w7, w8


if __name__ == "__main__":

    print("=====更新前的权值=====")
    print(w1.data, w2.data, w3.data, w4.data, w5.data, w6.data, w7.data, w8.data)

    for i in range(1000):
        print("=====第" + str(i) + "轮=====")
        L = loss_fuction(x1, x2, y1, y2)  # 前向传播，求 Loss，构建计算图
        L.backward()  # 自动求梯度，不需要人工编程实现。反向传播，求出计算图中所有梯度存入w中
        print("\tgrad W: ", round(w1.grad.item(), 2), round(w2.grad.item(), 2), round(w3.grad.item(), 2),
              round(w4.grad.item(), 2), round(w5.grad.item(), 2), round(w6.grad.item(), 2), round(w7.grad.item(), 2),
              round(w8.grad.item(), 2))
        w1, w2, w3, w4, w5, w6, w7, w8 = update_w(w1, w2, w3, w4, w5, w6, w7, w8)

    print("更新后的权值")
    print(w1.data, w2.data, w3.data, w4.data, w5.data, w6.data, w7.data, w8.data)

这次实现结果
在这里插入图片描述
上次实验结果：
在这里插入图片描述

2.对比【作业3】和【作业2】的程序，观察两种方法结果是否相同？如果不同，哪个正确？

这两次的权值更新的不同，这次的程序结果是正确的。

3.【作业2】程序更新（保留【作业2中】的错误答案，留作对比。新程序到作业3。）

import numpy as np


def sigmoid(z):
    a = 1 / (1 + np.exp(-z))
    return a

# 前馈神经网络：
# 输入为x1,x2,输出为o1,o2，其中还有一个隐藏层为h1,h2，
# 每一层分为in操作和out操作
# in = α * a + β * b 输入流的加权累加
# out = sigmoid(in) 对加权累加的结果进行非线性变换
def forward_propagate(x1, x2, y1, y2, w1, w2, w3, w4, w5, w6, w7, w8):
    in_h1 = w1 * x1 + w3 * x2   # 隐藏层
    out_h1 = sigmoid(in_h1)
    in_h2 = w2 * x1 + w4 * x2
    out_h2 = sigmoid(in_h2)

    in_o1 = w5 * out_h1 + w7 * out_h2   # out
    out_o1 = sigmoid(in_o1)
    in_o2 = w6 * out_h1 + w8 * out_h2
    out_o2 = sigmoid(in_o2)

    print("正向计算：o1 ,o2")    # 输出本轮进入损失函数之前的数值out1、out2
    print(round(out_o1, 5), round(out_o2, 5))   # round()舍入化整，round(x,y),y表保留小数后几位，此处保留5位小数

    # 损失函数MSE 均方误差：1/n * sum((y^-y)**2)
    # 此处只有2个y，所以n=2
    error = (1 / 2) * (out_o1 - y1) ** 2 + (1 / 2) * (out_o2 - y2) ** 2

    print("损失函数：均方误差")    # 输出本轮损失函数
    print(round(error, 5))

    return out_o1, out_o2, out_h1, out_h2   # 返回了两层out，用于反向传播


def back_propagate(out_o1, out_o2, out_h1, out_h2):
    # 反向传播
    d_o1 = out_o1 - y1
    d_o2 = out_o2 - y2
    # print(round(d_o1, 2), round(d_o2, 2))

    d_w5 = d_o1 * out_o1 * (1 - out_o1) * out_h1
    d_w7 = d_o1 * out_o1 * (1 - out_o1) * out_h2
    # print(round(d_w5, 2), round(d_w7, 2))
    d_w6 = d_o2 * out_o2 * (1 - out_o2) * out_h1
    d_w8 = d_o2 * out_o2 * (1 - out_o2) * out_h2
    # print(round(d_w6, 2), round(d_w8, 2))

    d_w1 = (d_o1 * out_h1 * (1 - out_h1) * w5 + d_o2 * out_o2 * (1 - out_o2) * w6) * out_h1 * (1 - out_h1) * x1
    d_w3 = (d_o1 * out_h1 * (1 - out_h1) * w5 + d_o2 * out_o2 * (1 - out_o2) * w6) * out_h1 * (1 - out_h1) * x2
    d_w2 = (d_o1 * out_h1 * (1 - out_h1) * w7 + d_o2 * out_o2 * (1 - out_o2) * w8) * out_h2 * (1 - out_h2) * x1
    d_w4 = (d_o1 * out_h1 * (1 - out_h1) * w7 + d_o2 * out_o2 * (1 - out_o2) * w8) * out_h2 * (1 - out_h2) * x2
    # print(round(d_w2, 2), round(d_w4, 2))
    print("反向传播：误差传给每个权值")
    print(round(d_w1, 5), round(d_w2, 5), round(d_w3, 5), round(d_w4, 5), round(d_w5, 5), round(d_w6, 5),
          round(d_w7, 5), round(d_w8, 5))

    return d_w1, d_w2, d_w3, d_w4, d_w5, d_w6, d_w7, d_w8


def update_w(w1, w2, w3, w4, w5, w6, w7, w8):
    # 步长
    step = 1
    w1 = w1 - step * d_w1
    w2 = w2 - step * d_w2
    w3 = w3 - step * d_w3
    w4 = w4 - step * d_w4
    w5 = w5 - step * d_w5
    w6 = w6 - step * d_w6
    w7 = w7 - step * d_w7
    w8 = w8 - step * d_w8
    return w1, w2, w3, w4, w5, w6, w7, w8


if __name__ == "__main__":
    w1, w2, w3, w4, w5, w6, w7, w8 = 0.2, -0.4, 0.5, 0.6, 0.1, -0.5, -0.3, 0.8
    x1, x2 = 0.5, 0.3
    y1, y2 = 0.23, -0.07
    print("=====输入值：x1, x2；真实输出值：y1, y2=====")
    print(x1, x2, y1, y2)
    print("=====更新前的权值=====")
    print(round(w1, 2), round(w2, 2), round(w3, 2), round(w4, 2), round(w5, 2), round(w6, 2), round(w7, 2),
          round(w8, 2))

    for i in range(1000):
        print("=====第" + str(i) + "轮=====")
        out_o1, out_o2, out_h1, out_h2 = forward_propagate(x1, x2, y1, y2, w1, w2, w3, w4, w5, w6, w7, w8)
        d_w1, d_w2, d_w3, d_w4, d_w5, d_w6, d_w7, d_w8 = back_propagate(out_o1, out_o2, out_h1, out_h2)
        w1, w2, w3, w4, w5, w6, w7, w8 = update_w(w1, w2, w3, w4, w5, w6, w7, w8)

    print("更新后的权值")
    print(round(w1, 2), round(w2, 2), round(w3, 2), round(w4, 2), round(w5, 2), round(w6, 2), round(w7, 2),round(w8, 2))

更新后的结果，和pytorch的结果基本上相同存在一点误差。
在这里插入图片描述

4.对比【作业2】与【作业3】的反向传播的实现方法。总结并陈述。

错误的原因主要是慕课上的推导退错了，要正确的链式求导。具体求解过程参考以下。

人工智能

5.激活函数Sigmoid用PyTorch自带函数torch.sigmoid()，观察、总结并陈述。

用torch.sigmoid()替换自己写端sigmoid函数

def forward_propagate(x1, x2):
    in_h1 = w1 * x1 + w3 * x2
    out_h1 = torch.sigmoid(in_h1)  # out_h1 = torch.sigmoid(in_h1)
    in_h2 = w2 * x1 + w4 * x2
    out_h2 = torch.sigmoid(in_h2)  # out_h2 = torch.sigmoid(in_h2)

    in_o1 = w5 * out_h1 + w7 * out_h2
    out_o1 = torch.sigmoid(in_o1)  # out_o1 = torch.sigmoid(in_o1)
    in_o2 = w6 * out_h1 + w8 * out_h2
    out_o2 = torch.sigmoid(in_o2)  # out_o2 = torch.sigmoid(in_o2)

    print("正向计算：o1 ,o2")
    print(out_o1.data, out_o2.data)

    return out_o1, out_o2

结果没啥区别。
在这里插入图片描述

6.激活函数Sigmoid改变为Relu，观察、总结并陈述。

def forward_propagate(x1, x2):
    in_h1 = w1 * x1 + w3 * x2
    out_h1 = torch.relu(in_h1)  # out_h1 = torch.sigmoid(in_h1)
    in_h2 = w2 * x1 + w4 * x2
    out_h2 = torch.relu(in_h2)  # out_h2 = torch.sigmoid(in_h2)

    in_o1 = w5 * out_h1 + w7 * out_h2
    out_o1 = torch.relu(in_o1)  # out_o1 = torch.sigmoid(in_o1)
    in_o2 = w6 * out_h1 + w8 * out_h2
    out_o2 = torch.relu(in_o2)  # out_o2 = torch.sigmoid(in_o2)

    print("正向计算：o1 ,o2")
    print(out_o1.data, out_o2.data)

    return out_o1, out_o2

ReLU只需要max()，计算更简单，收敛快。
在这里插入图片描述

7.损失函数MSE用PyTorch自带函数 t.nn.MSELoss()替代，观察、总结并陈述。

将损失函数替换为torch.nn.MSELoss()函数：

def loss_fuction(x1, x2, y1, y2):
    y1_pred, y2_pred = forward_propagate(x1, x2)
    t = torch.nn.MSELoss()
    loss = t(y1_pred,y1) + t(y2_pred,y2)
    print("损失函数（均方误差）：", loss.item())
    return loss

在这里插入图片描述

8.损失函数MSE改变为交叉熵，观察、总结并陈述。

def loss_fuction(x1, x2, y1, y2): 
    y1_pred, y2_pred = forward_propagate(x1, x2) 
    loss_func = torch.nn.CrossEntropyLoss() # 创建交叉熵损失函数
    y_pred = torch.stack([y1_pred, y2_pred], dim=1) 
    y = torch.stack([y1, y2], dim=1)
    loss = loss_func(y_pred, y) # 计算
    print("损失函数（均方误差）：", loss.item())
    return loss

在这里插入图片描述

9.改变步长，训练次数，观察、总结并陈述。

step = 1

=====第999轮=====
正向计算：o1 ,o2
tensor([0.9929]) tensor([0.0072])
损失函数（均方误差）： -0.018253758549690247
	grad W:  -0.0 -0.0 -0.0 -0.0 -0.0 0.0 -0.0 0.0
更新后的权值
tensor([2.2809]) tensor([0.6580]) tensor([1.7485]) tensor([1.2348]) tensor([3.8104]) tensor([-4.2013]) tensor([2.5933]) tensor([-2.0866])

step = 5

正向计算：o1 ,o2
tensor([0.9989]) tensor([0.0011])
损失函数（均方误差）： -0.01962665468454361
	grad W:  -0.0 -0.0 -0.0 -0.0 -0.0 0.0 -0.0 0.0
更新后的权值
tensor([2.8660]) tensor([1.2774]) tensor([2.0996]) tensor([1.6064]) tensor([4.7890]) tensor([-5.1927]) tensor([3.3955]) tensor([-2.8994])

step = 100

=====第999轮=====
正向计算：o1 ,o2
tensor([1.0000]) tensor([4.6485e-05])
损失函数（均方误差）： -0.019867710769176483
	grad W:  -0.0 -0.0 -0.0 -0.0 -0.0 0.0 -0.0 0.0
更新后的权值
tensor([3.5661]) tensor([2.0152]) tensor([2.5197]) tensor([2.0491]) tensor([6.4661]) tensor([-6.8819]) tensor([4.7917]) tensor([-4.3096])

10.权值w1-w8初始值换为随机数，对比【作业2】指定权值结果，观察、总结并陈述。

w1, w2, w3, w4, w5, w6, w7, w8 = torch.randn(1, 1), torch.randn(1, 1), torch.randn(1, 1), torch.randn(1, 1), torch.randn(1, 1), torch.randn(1, 1), torch.randn(1, 1), torch.randn(1, 1)

在这里插入图片描述

在这里插入图片描述
运行结果都有较大差别说明权值的选择也很重要。

11.全面总结反向传播原理和编码实现，认真写心得体会。

反向传播原理：通过反向传播不断的优化权值来优化模型使损失函数最小。我们这次作业更深入的理解了神经网络，学会了反向传播的具体实现（链式法则），也练习了python的使用有较大的提升。

海绵宝宝选购儿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pytorch深度学习实践第八讲课后习题 训练titanic数据集
weixin_46047643的博客
03-29 1420
本节没有课程传送门，算是博主根据老师讲的内容做的作业。 数据集传送门 Titanic dataset 这里对数据集进行了一些处理，首先第一行不能是属性名而非特征，不能使用所以在第一个表格前 加了'#'，另外有一些无用特征比如乘客姓名这里选择了直接跳过，最后在处理过发现np.loadtxt函数 不能识别'str'类型数据，尔数据集最后一项只有三个类别，所以用表格替换做了'0','1','2'标记替换。 import torch from torch.utils.data import Dataset
阿里巴巴2018人工智能算法岗笔试题
09-07
新鲜出炉的阿里巴巴笔试题，今年人工智能两个答题全部都是NLP
pytorch练习（1）
lb521200200的专栏
02-09 989
import torch import torch.nn as nn import torch.nn.functional as F class Net(nn.Module): def __init__(self): super(Net, self).__init__() # 1 input image channel, 6 output channels, 5x5 square convolution # kernel self.
4.pytorch 线性代数基础练习
爱飞的企鹅
05-20 157
import os os.makedirs(os.path.join('..','data'),exist_ok=True) datafile = os.path.join('..','data','house_tiny.csv') with open(datafile,'w') as f: f.write('NumRooms,Alley,Price\n') f.write('NA,Pave,127500\n') f.write('2,NA,106000\n') f.wri
人工智能的编程示例 爱因斯坦推理题
红孩儿编程大师
11-01 1008
人工智能的编程示例 爱因斯坦推理题 1.在一条街上，有5座房子，喷了5种颜色。 2.每个房里住着不同国籍的人。 3.每个人喝不同的饮料，抽不同品牌的香烟，养不同的宠物。 其中： (1)、英国人住在红色的房子里； (2)、瑞典人养狗作为宠物； (3)、丹麦人喝茶； (4)、绿房子紧挨着白房子，在白房子的左边； (5)、绿房子的主人喝咖啡； (6)、抽Pall Mall牌香烟的人养鸟； (7)、黄色房子里的人抽Dunhill牌香烟； (8)、住在中间那个房子里的人喝牛奶； (9)、挪威人住在第一个房子
数据结构-C语言版：二叉树例题.ppt
06-16
数据结构-C语言版：二叉树例题.ppt 本资源是关于数据结构的知识点总结，主要围绕二叉树的概念和算法进行介绍。下面是相关知识点的详细解释： 一、 二叉树的定义 二叉树是一种特殊的树形结构，其中每个结点最多...
数据结构-C语言版：单链表例题.ppt
06-06
数据结构-C语言版：单链表例题.ppt
数据结构-C语言版：三元组例题.ppt
06-16
数据结构-C语言版：三元组例题.ppt
【顺丰科技】 2019校招 人工智能与机器学习工程师在线考试 笔试编程题
ferb的语音识别学习小站
11-08 1630
#!/bin/python # -*- coding: utf8 -*- import sys import os import re #请完成下面这个函数，实现题目要求的功能 #当然，你也可以不按照下面这个模板来作答，完全按照自己的想法来 ^-^ #******************************开始写代码****************************** def...
编程题汇总1
Codeur的博客
06-08 418
实习笔试题汇总1
西工大--人工智能程序设计noj--前60道
weixin_52999035的博客
12-10 2951
西工大-人工智能程序设计noj-前60道-2022-秋
60题PyTorch简易入门指南，做技术的弄潮儿
最新发布
qq_41081716的博客
12-17 58
26.定义①的卷积层，输入为32x32的图像，卷积核大小5x5卷积核种类6# 27.定义③的卷积层，输入为前一层6个特征，卷积核大小5x5，卷积核种类16# 28.定义⑤的全链接层，输入为16*5*5，输出为120# 29.定义⑥的全连接层，输入为120，输出为84# 30.定义⑥的全连接层，输入为84，输出为10# 31.完成input-S2，先卷积+relu，再2x2下采样# 32.完成S2-S4，先卷积+relu，再2x2下采样。
Pytorch深度学习
wangprince2017
03-15 2840
一、单选题（共20题；共100.0分） 1.pytorch的前身是（ ） （5.0分）A.Python B.lua C.torch D.numpy 5.0分 2.在选择神经网络的深度时，下面哪些参数需要考虑？1 神经网络的类型(如MLP,CNN) 2 输入数据 3 计算能力(硬件和软件能力决定) 4 学习速率 5 映射的输出函数 （5.0分）A.1,2,4,5 B.2,3,4,5 C.都需要考虑 D.1,3,4,5 5.0分 3.当在卷积神经网络中加入池化层(pooling l..
人工智能考试复习题（自己背的）
PZ的博客
05-18 5万+
选择题： 人工智能的含义最早由一位科学家于1950年提出,并且同时提出一个机器智能的测试模型,请问这个科学家是：（图灵） 神经网络研究属于下列（连接主义）学派。 产生式系统的推理不包括（简单推理）。 下列不在人工智能系统知识包含的4个要素中（关系）。 要想让机器具有智能，必须让机器具有知识。因此在人工智能中有一个研究领域，主要眼球计算机如何自动获取知识和技能，实现自我完善，这门研究分支学...
《人工智能》课程习题
热门推荐
GarfieldEr007的专栏
12-08 5万+
《人工智能》课程习题 第一章  绪    论 1-1.  什么是人工智能？试从学科和能力两方面加以说明。 1-2.  在人工智能的发展过程中，有哪些思想和思潮起了重要作用？ 1-3.  为什么能够用机器（计算机）模仿人的智能？ 1-4.  现在人工智能有哪些学派？它们的认知观是什么？ 1-5.  你认为应从哪些层次对认知行为进行研究？ 1-6.  人工智能的主要研究和应用领域是什么？
人工智能练习题【含答案】
pattyi的博客
05-05 1万+
谓词表示 1(单选题) 命题是可以判断真假的（） 正确答案: D A. 祈使句 B. 疑问句 C. 感叹句 D. 陈述句 2(单选题) 李明的父亲是教师，用谓词逻辑可以表示为Teacher（father（Liming））这里father（Liming）是（ ） 正确答案: C A. 常量 B. 变元 C. 函数 D. 一元谓词 3(单选题) （ ）表示“每个人都有喜欢的人”。 正确答案: A. (∀x)(∀y)Like(x,y) B. (∀x)(∃y)Like(x
西门子s7-200smart案例例题
05-15
以下是一道S7-200 Smart案例例题： 某工厂的生产车间需要控制一组用于搬运产品的机械臂，其中包括三个电机和一个夹爪。电机1和2分别控制机械臂的上下移动和旋转，电机3控制夹爪的开合。机械臂需要按照指定位置和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值