NNDL 作业3：分别使用numpy和pytorch实现FNN例题

已于 2022-10-01 22:04:35 修改
阅读量442 收藏
点赞数 1
文章标签： numpy pytorch python
于 2022-10-01 22:02:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56164577/article/details/127136696
版权

不知道为啥这次没目录，勉强看吧。

分别使用numpy和pytorch实现FNN例题

1.过程推导 - 了解BP原理
2.数值计算 - 手动计算，掌握细节
3.代码实现 - numpy手推 + pytorch自动

代码实现：
在这里插入图片描述
需要解决的问题：

1.对比【numpy】和【pytorch】程序，总结并陈述。
2.激活函数Sigmoid用PyTorch自带函数torch.sigmoid()，观察、总结并陈述。
3.激活函数Sigmoid改变为Relu，观察、总结并陈述。
4.损失函数MSE用PyTorch自带函数 t.nn.MSELoss()替代，观察、总结并陈述。
5.损失函数MSE改变为交叉熵，观察、总结并陈述。
6.改变步长，训练次数，观察、总结并陈述。
7.权值w1-w8初始值换为随机数，对比“指定权值”的结果，观察、总结并陈述。
8.权值w1-w8初始值换为0，观察、总结并陈述。
9.全面总结反向传播原理和编码实现，认真写心得体会。

过程推导 - 了解BP原理

在这里插入图片描述
在这里插入图片描述

数值计算 - 手动计算，掌握细节

在这里插入图片描述

代码实现

对比【numpy】和【pytorch】程序，总结并陈述。

numpy

import numpy as np

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("输入值 x0, x1:", x1, x2)
print("输出值 y0, y1:", y1, y2)


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


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_o1 = sigmoid(in_o1)
    in_o2 = w6 * out_h1 + w8 * out_h2
    out_o2 = sigmoid(in_o2)

    print("正向计算，隐藏层h1 ,h2：", end="")
    print(round(out_h1, 5), round(out_h2, 5))
    print("正向计算，预测值o1 ,o2：", end="")
    print(round(out_o1, 5), round(out_o2, 5))

    error = (1 / 2) * (out_o1 - y1) ** 2 + (1 / 2) * (out_o2 - y2) ** 2

    print("损失函数(均方误差)：",round(error, 5))

    return out_o1, out_o2, out_h1, out_h2


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

    d_w5 = d_o1 * out_o1 * (1 - out_o1) * out_h1
    d_w7 = d_o1 * out_o1 * (1 - out_o1) * out_h2
    d_w6 = d_o2 * out_o2 * (1 - out_o2) * out_h1
    d_w8 = d_o2 * out_o2 * (1 - out_o2) * out_h2

    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("w的梯度:",round(d_w1, 2), round(d_w2, 2), round(d_w3, 2), round(d_w4, 2), round(d_w5, 2), round(d_w6, 2),
          round(d_w7, 2), round(d_w8, 2))

    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__":

    print("权值w0-w7:",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(5):
        print("=====第" + str(i+1) + "轮=====")
        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("更新后的权值w:",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

import torch

x = [0.5, 0.3]  # x0, x1 = 0.5, 0.3
y = [0.23, -0.07]  # y0, y1 = 0.23, -0.07
print("输入值 x0, x1:", x[0], x[1])
print("输出值 y0, y1:", y[0], y[1])
w = [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])]  # 权重初始值
for i in range(0, 8):
    w[i].requires_grad = True
print("权值w0-w7:")
for i in range(0, 8):
    print(w[i].data, end="  ")


def forward_propagate(x):  # 计算图
    in_h1 = w[0] * x[0] + w[2] * x[1]
    out_h1 = torch.sigmoid(in_h1)
    in_h2 = w[1] * x[0] + w[3] * x[1]
    out_h2 = torch.sigmoid(in_h2)

    in_o1 = w[4] * out_h1 + w[6] * out_h2
    out_o1 = torch.sigmoid(in_o1)
    in_o2 = w[5] * out_h1 + w[7] * out_h2
    out_o2 = torch.sigmoid(in_o2)

    print("正向计算，隐藏层h1 ,h2：", end="")
    print(out_h1.data, out_h2.data)
    print("正向计算，预测值o1 ,o2：", end="")
    print(out_o1.data, out_o2.data)

    return out_o1, out_o2


def loss(x, y):  # 损失函数
    y_pre = forward_propagate(x)  # 前向传播
    loss_mse = (1 / 2) * (y_pre[0] - y[0]) ** 2 + (1 / 2) * (y_pre[1] - y[1]) ** 2  # 考虑 ： t.nn.MSELoss()
    print("损失函数(均方误差)：", loss_mse.item())
    return loss_mse


if __name__ == "__main__":
    for k in range(1):
        print("\n=====第" + str(k+1) + "轮=====")
        l = loss(x, y)  # 前向传播，求 Loss，构建计算图
        l.backward()  # 反向传播，求出计算图中所有梯度存入w中. 自动求梯度，不需要人工编程实现。
        print("w的梯度: ", end="  ")
        for i in range(0, 8):
            print(round(w[i].grad.item(), 2), end="  ")  # 查看梯度
        step = 1  # 步长
        for i in range(0, 8):
            w[i].data = w[i].data - step * w[i].grad.data  # 更新权值
            w[i].grad.data.zero_()  # 注意：将w中所有梯度清零
        print("\n更新后的权值w:")
        for i in range(0, 8):
            print(w[i].data, end="  ")

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

从上面代码运行结果中可以看出当训练的轮数少的时候使用Sigmoid函数和使用Pytorch自带函数torch.sigmoid()并没有什么较明显的差距，当轮数多的时候，可以看出torch.sigmoid()的精度高一些。

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

Relu
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
Relu是一个非常优秀的激活哈数，相比较于传统的Sigmoid函数，有三个作用：

  1. 防止梯度弥散
  2. 稀疏激活性
  3. 加快计算
    损失函数(均方误差)下降的更快，在训练第五轮时就降到比较低的程度，所以说ReLU函数的收敛速度比Sigmoid函数更快。

ReLU函数可以使一部分神经元的输出为0，就造成了网络的稀疏性，即稀疏激活性，并且减少了参数之间的相互依存关系，防止梯度弥散。

4.损失函数MSE用PyTorch自带函数 t.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

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
由上图可以看出，50轮是一样，但是最终收敛结果不一样，手写的要比torch.nn.MSELoss()收敛的结果好些。

5.损失函数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

在这里插入图片描述
在这里插入图片描述
当训练轮数为500时，损失函数已经变为负的了。

MSE 损失主要适用与回归问题，因为优化 MSE 等价于对高斯分布模型做极大似然估计，而简单回归中做服从高斯分布的假设是比较合理的
交叉熵损失主要适用于多分类问题，因为优化交叉熵损失等价于对多项式分布模型做极大似然估计，而多分类问题通常服从多项式分布

import matplotlib.pyplot as plt
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)
    Y = []
    X = []

    for i in range(50):
        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)
        Y.append(L.item())
        X.append(i)

    plt.rcParams['font.sans-serif'] = ['SimHei']  # 可以plt绘图过程中中文无法显示的问题
    plt.plot(X, Y)
    plt.xlabel('迭代次数')
    plt.ylabel('Loss，step=1')
    plt.show()
    print("更新后的权值")
    print(w1.data, w2.data, w3.data, w4.data, w5.data, w6.data, w7.data, w8.data)

step=1
在这里插入图片描述
在这里插入图片描述

step=3

在这里插入图片描述
在这里插入图片描述

step=0.1
在这里插入图片描述
在这里插入图片描述

7.权值w1-w8初始值换为随机数，对比“指定权值”的结果，观察、总结并陈述。

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

在这里插入图片描述
改变随机数值，改变了权值，但对收敛速度基本没有影响。

8.权值w1-w8初始值换为0，观察、总结并陈述。

在这里插入图片描述
在这里插入图片描述
可以观察到，在前50轮Loss变大，即收敛速度慢，后收敛结果不变。

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

反向传播算法的原理是利用链式求导法则计算实际输出结果与理想结果之间的损失函数对每个权重参数或偏置项的偏导数，然后根据优化算法逐层反向地更新权重或偏置项，它采用了前向-后向传播的训练方式，通过不断调整模型中的参数，使损失函数达到收敛，从而构建准确的模型结构。

   反向传播算法可分为三个步骤：

  （1）前向传播。将样本数据输入至网络，数据从输入层经过逐层计算传送到输出层，得到相应的实际输出结果。

  （2）反向计算第L层神经元i的误差项，它表示网络的损失函数E对神经元的输出值的偏导数。

  （3）根据优化算法计算每个神经元参数的梯度，并更新每个参数。

通过对反向传播BP公式的手动求导，对他的转变过程认识更加深刻一些，以及对反向传播的各个步骤，代码实现，都有加强。

叶雨柳光
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FNN類神經網路
08-17
程式碼
FNN
qq_41786778的博客
03-09 733
https://blog.csdn.net/xiewenbo/article/details/52038493 https://www.cnblogs.com/qcloud1001/p/7513982.html https://www.jiqizhixin.com/articles/2018-07-16-17 https://blog.csdn.net/han_xiaoyang/articl...
使用Python构建参数化FNN（一）——构建可自定义结构的FNN
qq_41959920的博客
04-08 2046
提示：转载请注明出处，若本文无意侵犯到您的合法权益，请及时与作者联系。 文章目录 一、 神经元与神经层的输出计算 二、 实现一个2*3*1的FNN 三、 实现一个自定义结构的FNN 一、 神经元与神经层的输出计算 从单个神经元的角度看，我们输入一个x，它经过自身的权重、偏置和激励函数(以Sigmoid为例)返还一个输出值。 从单个神经层（假设有3个神经元）的角度看，我们输入一个向量,它经过自身的权重矩阵、偏置向量和激励函数(以Sigmoid为例)返还一个输出向量。 在上述描述中，我们使用
多层感知机（MLP）、全连接神经网络（FCNN）、前馈神经网络（FNN）、深度神经网络（DNN）与BP算法详解
热门推荐
weixin_60737527的博客
06-27 2万+
多层感知机（MLP）、全连接神经网络（FCNN）、前馈神经网络（FNN）、深度神经网络（DNN）与BP算法详解。
NNDL:神经网络和深度学习课程回购
04-12
作业3： 它包括对点采样的随机梯度下降优化器的实现，该点取自线y = 2 * x + 3的方程式。作业4： 联合碳化物数据集上的随机梯度下降的实现。作业5： 它由微型批次梯度下降优化器的实现组成，该优化器用于对点样本...
NNDL:使用python的梯度下降算法
03-25
本主题将深入探讨如何在Python环境中，结合Jupyter Notebook工具实现梯度下降算法，以便于理解和应用到实际的神经网络模型中。 一、梯度下降算法基础 梯度下降是一种迭代优化算法，用于寻找函数的局部最小值。在...
NNDL-solutions:迈克尔·尼尔森（Michael Nielsen）的《神经网络与深度学习》一书中的练习和问题的解决方案
05-03
迈克尔·尼尔森（Michael Nielsen）的书《 （以及对Python 3和Theano 1.0.3的代码的改编）中的练习和问题的解决方案（数学和代码）。 在这里找到练习和问题的解决方案： 涉及数学： notebooks 涉及代码：以code...
nndl：神经网络和深度学习的另一种中文翻译
02-21
神经网络和深度学习的另一种中文翻译 这是迈克尔·尼尔森（Michael Nielsen）的《另一本（正在进行中的）中文译本，最初是我对这本免费在线书的学习笔记。 它是用LaTeX编写的，以使数学方程式和曲线图具有更好的外观...
锻炼：锻炼nndl
02-26
本次作业需要首先安装anaconda3下载地址 2.0 pytorch> 0.4 锻炼 1.热身练习热身 numpy是Python中对于矩阵处理很实用的工具包，本小节作业主要是熟悉基本的numpy操作。 2.线性回归模型 3.线性模型 支持向量机 Softmax...
TensorFlow 和 PyTorch 显示模型参数方法详解
qlkaicx的博客
07-08 291
在深度学习中，了解和显示模型参数是模型开发和调试的重要环节。不同的深度学习框架提供了不同的方式来查看模型的结构和参数。在 PyTorch 中，显示模型参数和结构的方法与 TensorFlow 不同。方法非常直观，输出模型的总体结构、每层的名称、输出形状以及参数数量。在 TensorFlow 和 PyTorch 中，显示模型参数和结构的方法各有特点。在 TensorFlow 中，特别是使用 Keras 接口时，我们通常使用。，我们可以获得模型所有参数的详细信息，包括参数的名称和尺寸。来显示模型的参数和结构。
LPRNet 车牌识别部署 rk3588（pt-onnx-rknn）包含各个步骤完整板端代码
zhangqian_1的博客
07-11 273
虽然车牌识别技术很成熟了，但完全没有接触过。一直想搞一下、整一下、试一下、折腾一下，工作之余找了一个简单的例子入个门。本博客简单记录一下 LPRNet 车牌识别部署 rk3588流程，训练参考 LPRNet 官方代码。1、导出onnx导出onnx很容易，在推理时加入保存onnx代码，但用onnx推理时发现推理识别，有算子onnx推理时不支持，看了一下不支持的操作 nn.MaxPool3d() ，查了一下资料有等价的方法，用等价方法替换后推理结果是一致的。保存onnx代码。
Pytorch 实践手写数字识别深度学习网络 LeNet-5
Go_ahead_forever的博客
07-07 1408
Pytorch 实践手写数字识别深度学习网络 LeNet-5
pytorch-RNN存在的问题
wyw0000的博客
07-11 347
RNN存在的问题及解决办法
windows中超详细深度学习环境配置之安装显卡驱动、cuda、cudnn、pytorch、torchvision、pycharm
qq_15060477的博客
07-11 472
安装完成后，可以按win+r键盘，输入cmd回车，弹出如下所示终端，输入nvidia-smi，若显示如下，则说明驱动已经安装好了。我可以装的最高版本是12.5，我下载12.1.0版本的cuda（主要是为了能下载到对应版本的pytorch，版本太高，对应pytorch都很难下载到哦）双击所下载的cuda安装包，然后选择安装的目录，本人默认，然后单击OK，接着一路的选择如以下图所示，按照顺序依次走完就安装完成了。安装cuda时，注意版本对应问题，下图中的1表示你可以安装的cuda的最高版本。
基于前馈神经网络 FNN 实现股票单变量时间序列预测(PyTorch版)
君子不器 大道无方
07-11 572
前馈神经网络（Feedforward Neural Network, FNN）作为深度学习中的一种基本网络结构，以其强大的非线性拟合能力和自适应性，在金融时间序列预测中展现出巨大的潜力。前馈神经网络通过模拟人脑神经元的连接方式，构建了一个多层次的计算模型，能够自动学习和提取数据中的复杂特征和规律，从而对未来的市场走势进行预测。
Transformer——多头注意力机制（Pytorch）
最新发布
m0_52507142的博客
07-11 61
【代码】Transformer——多头注意力机制（Pytorch）
第N7周：seq2seq翻译实战-pytorch复现-小白版
S153580的博客
07-11 660
在序列生成的任务中，如机器翻译或文本生成，解码器（decoder）的输入通常是由解码器自己生成的预测结果，即前一个时间步的输出。GRU是一种RNN（循环神经网络）的变体，它将传统的RNN的三个门（输入门、遗忘门和输出门）合并为两个门（更新门和重置门）。GRU是一种RNN（循环神经网络）的变体，它将传统的RNN的三个门（输入门、遗忘门和输出门）合并为两个门（更新门和重置门）。GRU是一种RNN（循环神经网络）的变体，它将传统的RNN的三个门（输入门、遗忘门和输出门）合并为两个门（更新门和重置门）。
VGG16 实现图像分类的 pytorch 实现、步骤精讲
Go_ahead_forever的博客
07-10 882
VGG16 实现图像分类
python FNN
09-05
- *2* [NNDL 作业3：分别使用numpy和pytorch实现FNN例题](https://blog.csdn.net/qq_51713698/article/details/127135938)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值