【实验五】前馈神经网络（1）-神经元、激活函数

一、神经元

使用pytorch计算一组输入的净活性值

使用nn.Linear完成输入张量的上述变换

二、激活函数

使用python实现并可视化“Logistic函数、Tanh函数”

在pytorch中找到对张量的Logistic和Tanh计算函数并测试

使用python实现并可视化可视化“ReLU、带泄露的ReLU的函数

在pytorch中找到完成ReLU与带泄露的ReLU的计算函数并测试

实现其他激活函数

一、神经元

使用pytorch计算一组输入的净活性值


import torch
import torch.nn as nn
# 3个特征数为5的样本
X = torch.rand(size=[3, 5])
# 含有5个参数的权重向量
w = torch.rand(size=[5, 1])
# 偏置项
b = torch.rand(size=[1, 1])

# 使用'torch.matmul'实现矩阵相乘
z = torch.matmul(X, w) + b
print("（一）手动计算")
print("输入 X:", X)
print("权重 w:", w, "\n偏置 b:", b)
print("输出 z:", z)

运行结果：

（一）手动计算
输入 X: tensor([[0.4216, 0.1479, 0.3056, 0.1849, 0.5328],
        [0.1214, 0.8136, 0.5596, 0.3313, 0.2306],
        [0.4608, 0.3240, 0.3993, 0.8227, 0.3570]])
权重 w: tensor([[0.4860],
        [0.1411],
        [0.8563],
        [0.1224],
        [0.4584]]) 
偏置 b: tensor([[0.9705]])
输出 z: tensor([[1.7248],
        [1.7697],
        [1.8465]])

使用nn.Linear完成输入张量的上述变换


import torch
import torch.nn as nn
# 3个特征数为5的样本
X = torch.rand(size=[3, 5])
#=======================================================================
# 定义线性层，输入维度为5，输出维度为1
linear_layer = nn.Linear(in_features=5, out_features=1,bias=False)
# 使用线性层对输入X进行变换
z = linear_layer(X)
# 打印输入、权重、偏置和输出
print("(二）使用nn.Linear函数计算")
print("输入 X:", X)
print("线性层权重 w:", linear_layer.weight)
print("线性层偏置 b:", linear_layer.bias)
print("输出 z:", z)

运行结果

(二）使用nn.Linear函数计算
输入 X: tensor([[0.4216, 0.1479, 0.3056, 0.1849, 0.5328],
        [0.1214, 0.8136, 0.5596, 0.3313, 0.2306],
        [0.4608, 0.3240, 0.3993, 0.8227, 0.3570]])
线性层权重 w: Parameter containing:
tensor([[-0.1735,  0.0095, -0.0971, -0.1582, -0.1315]], requires_grad=True)
线性层偏置 b: None
输出 z: tensor([[-0.2008],
        [-0.1504],
        [-0.2928]], grad_fn=<MmBackward0>)

因为偏置默认为false,这里我们设置为了true，所以最终输出为b=0。

观察结果我还发现了一个处，权重输出是手动计算的权重输出的转置！！【在 nn.Linear(in_features, out_features) 中，权重矩阵 W 的维度是 [out_features, in_features]。而普通的矩阵乘法，权重矩阵通常是 [in_features, out_features] 的维度。】

二、激活函数

使用python实现并可视化“Logistic函数、Tanh函数”

import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

# 定义激活函数
def logistic(z):
    return 1.0 / (1.0 + np.exp(-z))
def tanh(z):
    exp_z = np.exp(z)  # 计算 e^z
    exp_neg_z = np.exp(-z)  # 计算 e^{-z}
    return (exp_z - exp_neg_z) / (exp_z + exp_neg_z)  # 返回 Tanh 结果

# 绘制函数曲线
def plot_activation_functions():
    z = np.linspace(-10, 10, 10000)  # 生成输入值
    plt.figure(figsize=(10, 6))  # 设置图形大小
    plt.plot(z, logistic(z), color='#e4007f', label="Logistic Function")
    plt.plot(z, tanh(z), color='#f19ec2', linestyle='--', label="Tanh Function")
    ax = plt.gca()
    ax.spines['top'].set_color('none')
    ax.spines['right'].set_color('none')
    ax.spines['left'].set_position(('data', 0))
    ax.spines['bottom'].set_position(('data', 0))
    plt.axhline(0, color='grey', lw=0.5, linestyle='--')  # 添加水平基线
    plt.axvline(0, color='grey', lw=0.5, linestyle='--')  # 添加垂直基线
    plt.title("Activation Functions")  # 添加标题
    plt.xlabel("Input (z)")  # x轴标签
    plt.ylabel("Output")  # y轴标签
    plt.legend(loc='lower right', fontsize='large')
    plt.grid(True)  # 添加网格
    plt.show()  # 显示图形
# 主函数
if __name__ == "__main__":
    plot_activation_functions()

在pytorch中找到对张量的Logistic和Tanh计算函数并测试

import torch
import torch.nn.functional as F
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

# 生成输入值
z = torch.linspace(-10, 10, 100)  # 在[-10, 10]范围内生成100个均匀分布的点
# 计算 Logistic 函数（Sigmoid）
logistic_output = F.sigmoid(z)  # 使用 torch.nn.functional.sigmoid 计算 Logistic 函数
# 计算 Tanh 函数
tanh_output = F.tanh(z)  # 使用 torch.tanh 计算 Tanh 函数
# 打印结果
print("输入 z:", z)
print("Logistic 函数输出:", logistic_output)
print("Tanh 函数输出:", tanh_output)
# 可视化结果
plt.figure(figsize=(10, 5))  # 创建一个 10x5 英寸的图形
# 绘制 Logistic 函数
plt.plot(z.numpy(), logistic_output.numpy(), color='purple', label='Logistic Function (Sigmoid)', linestyle='-')  # 绘制 Logistic 函数
# 绘制 Tanh 函数
plt.plot(z.numpy(), tanh_output.numpy(), color='orange', label='Tanh Function', linestyle='--')  # 绘制 Tanh 函数
# 设置图形属性
plt.title('Logistic and Tanh Functions')  # 设置标题
plt.xlabel('z')  # 设置 x 轴标签
plt.ylabel('Function Output')  # 设置 y 轴标签
plt.axhline(0, color='black', linewidth=0.5, linestyle='--')  # 绘制 y=0 的虚线
plt.axvline(0, color='black', linewidth=0.5, linestyle='--')  # 绘制 x=0 的虚线
plt.grid()  # 显示网格
plt.legend()  # 显示图例
plt.show()  # 显示图形

使用python实现并可视化可视化“ReLU、带泄露的ReLU的函数

import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

# 定义 ReLU 激活函数
def relu(z):
    return np.maximum(0, z)  # 当 z > 0 返回 z，否则返回 0

# 定义带泄露的 ReLU 激活函数
def leaky_relu(z, negative_slope=0.1):
    a1 = (z > 0) * z
    a2 = (z <= 0) * (negative_slope * z)
    return a1 + a2
# 绘制函数曲线
def plot_activation_functions():
    z = np.linspace(-10, 10, 1000)  # 生成输入值
    plt.figure(figsize=(10, 6))  # 设置图形大小

    # 绘制 ReLU 函数
    plt.plot(z, relu(z), color='#e4007f', label="ReLU Function", linestyle='-')

    # 绘制带泄露的 ReLU 函数
    plt.plot(z, leaky_relu(z), color='orange', linestyle='--', label="Leaky ReLU Function (alpha=0.01)")
    # 设置图形属性
    ax = plt.gca()
    ax.spines['top'].set_color('none')
    ax.spines['right'].set_color('none')
    ax.spines['left'].set_position(('data', 0))  # y轴与 x = 0 对齐
    ax.spines['bottom'].set_position(('data', 0))  # x轴与 y = 0 对齐
    plt.axhline(0, color='black', linewidth=0.5, linestyle='--')  # 添加水平基线
    plt.axvline(0, color='black', linewidth=0.5, linestyle='--')  # 添加垂直基线
    plt.title("ReLU and Leaky ReLU Activation Functions")  # 设置标题
    plt.xlabel("Input (z)")  # x轴标签
    plt.ylabel("Output")  # y轴标签
    plt.legend(loc='best', fontsize='large')  # 显示图例
    plt.grid(True)  # 添加网格
    plt.show()  # 显示图形

# 主函数
if __name__ == "__main__":
    plot_activation_functions()

使用 torch.linspace(-10, 10, 100) 在 [−10,10]范围内生成100个均匀分布的输入值 z，然后绘制其调用函数后对应的输出值，最终的图像与我们用sigmod和tanh公式计算的函数图像十一样的。

在pytorch中找到完成ReLU与带泄露的ReLU的计算函数并测试

import torch
import torch.nn.functional as F
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

# 生成输入值
z = torch.linspace(-10, 10, 100)  # 在[-10, 10]范围内生成100个均匀分布的点
# 计算 ReLU 函数
relu_output=F.relu(z)
# 计算带泄露的 ReLU 函数
leaky_relu_output = F.leaky_relu(z, negative_slope=0.1)
# 打印结果
print("输入 z:", z)
print("ReLU 函数输出:", relu_output)
print("带泄露的 ReLU 函数输出:", leaky_relu_output)

# 可视化结果
plt.figure(figsize=(10, 5))  # 创建一个 10x5 英寸的图形
# 绘制 ReLU 函数
plt.plot(z.numpy(), relu_output.numpy(), color='purple', label='ReLU Function', linestyle='-')  # 绘制 ReLU 函数
# 绘制带泄露的 ReLU 函数
plt.plot(z.numpy(), leaky_relu_output.numpy(), color='orange', label='Leaky ReLU Function', linestyle='--')  # 绘制 Leaky ReLU 函数
# 设置图形属性
plt.title('ReLU and Leaky ReLU Functions')  # 设置标题
plt.xlabel('z')  # 设置 x 轴标签
plt.ylabel('Function Output')  # 设置 y 轴标签
plt.axhline(0, color='black', linewidth=0.5, linestyle='--')  # 绘制 y=0 的虚线
plt.axvline(0, color='black', linewidth=0.5, linestyle='--')  # 绘制 x=0 的虚线
plt.grid()  # 显示网格
plt.legend()  # 显示图例
plt.show()  # 显示图形

通过输出的图像可以看出，使用 torch.linspace(-10, 10, 100) 在 [−10,10]范围内生成100个均匀分布的输入值 z，然后绘制其调用函数后对应的输出值，最终的图像与我们用relu公式计算的函数图像十一样的。

实现其他激活函数

这里我就直接调用了函数

import torch
import torch.nn.functional as F
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

# 生成输入值
z = torch.linspace(-10, 10, 100)

# 计算激活函数的输出
hard_sigmoid_output = F.hardsigmoid(z)  # Hard-Logistic (Hard-Sigmoid)
hard_tanh_output = F.hardtanh(z)  # Hard-Tanh
elu_output = F.elu(z)  # ELU
softplus_output = F.softplus(z)  # Softplus
swish_output = F.silu(z)  # 使用 SiLU 作为 Swish 的实现

# 可视化结果
plt.figure(figsize=(10, 5))

# 绘制各个激活函数的输出
plt.plot(z.numpy(), hard_sigmoid_output.numpy(), color='purple', label='Hard-Logistic (Hard-Sigmoid)', linestyle='-')
plt.plot(z.numpy(), hard_tanh_output.numpy(), color='blue', label='Hard-Tanh', linestyle='--')
plt.plot(z.numpy(), elu_output.numpy(), color='green', label='ELU', linestyle='-.')
plt.plot(z.numpy(), softplus_output.numpy(), color='red', label='Softplus', linestyle=':')
plt.plot(z.numpy(), swish_output.numpy(), color='orange', label='Swish (SiLU)', linestyle='-')

# 设置图形属性
plt.title('Activation Functions: Hard-Logistic, Hard-Tanh, ELU, Softplus, Swish')
plt.xlabel('z')
plt.ylabel('Function Output')
plt.axhline(0, color='black', linewidth=0.5, linestyle='--')
plt.axvline(0, color='black', linewidth=0.5, linestyle='--')
plt.grid()
plt.legend()
plt.show()