第 1 章：什么是神经网络 —— 从神经元到深度网络¶

import numpy as np

def neuron(inputs, weights, bias, activation="sigmoid"):
    """
    单个人工神经元

    参数:
        inputs:  输入信号列表 [x1, x2, ..., xn]
        weights: 权重列表 [w1, w2, ..., wn]
        bias:    偏置值 b
        activation: 激活函数类型

    返回:
        神经元的输出值
    """
    # 步骤1：加权求和 + 偏置
    z = np.dot(inputs, weights) + bias

    # 步骤2：通过激活函数
    if activation == "sigmoid":
        output = 1 / (1 + np.exp(-z))
    elif activation == "relu":
        output = max(0, z)
    elif activation == "step":
        output = 1 if z > 0 else 0
    else:
        output = z

    return output

# 示例：判断一张图片是否是"猫"
# 假设我们有 3 个特征：有尖耳朵(1/0)、有胡须(1/0)、体型小(1/0)
inputs  = np.array([1, 1, 1])      # 尖耳朵=有, 胡须=有, 体型小=是
weights = np.array([0.8, 0.5, 0.3]) # 尖耳朵最重要, 胡须次之, 体型再次之
bias    = -0.5                       # 稍微倾向于"不是猫"

result = neuron(inputs, weights, bias, activation="sigmoid")
print(f"这是猫的概率: {result:.4f}")  # 输出: 这是猫的概率: 0.7503

import numpy as np
import matplotlib.pyplot as plt

z = np.linspace(-10, 10, 100)
sigmoid = 1 / (1 + np.exp(-z))

plt.plot(z, sigmoid)
plt.axhline(y=0.5, color='gray', linestyle='--')
plt.axvline(x=0, color='gray', linestyle='--')
plt.title("Sigmoid 激活函数")
plt.xlabel("z (加权和)")
plt.ylabel("f(z)")
plt.grid(True, alpha=0.3)
plt.show()

z = np.linspace(-10, 10, 100)
relu = np.maximum(0, z)

plt.plot(z, relu, color='green')
plt.title("ReLU 激活函数")
plt.xlabel("z (加权和)")
plt.ylabel("f(z)")
plt.grid(True, alpha=0.3)
plt.show()

import numpy as np

class SimpleNeuralNetwork:
    """
    一个简单的三层神经网络
    输入层: 784 个神经元 (28x28 像素)
    隐藏层: 128 个神经元
    输出层: 10 个神经元 (数字 0-9)
    """

    def __init__(self):
        # 随机初始化权重（小随机数打破对称性）
        self.W1 = np.random.randn(784, 128) * 0.01
        self.b1 = np.zeros((1, 128))
        self.W2 = np.random.randn(128, 10) * 0.01
        self.b2 = np.zeros((1, 10))

    def sigmoid(self, z):
        return 1 / (1 + np.exp(-z))

    def softmax(self, z):
        """将输出转换为概率分布"""
        exp_z = np.exp(z - np.max(z, axis=1, keepdims=True))
        return exp_z / np.sum(exp_z, axis=1, keepdims=True)

    def forward(self, X):
        """
        前向传播：数据从输入层流向输出层

        参数:
            X: 输入数据，形状 (样本数, 784)

        返回:
            每个类别的概率，形状 (样本数, 10)
        """
        # 第一层：输入 → 隐藏层
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)

        # 第二层：隐藏层 → 输出层
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.softmax(self.z2)

        return self.a2

# 创建一个网络实例
nn = SimpleNeuralNetwork()
print(f"W1 形状: {nn.W1.shape}")  # (784, 128) —— 784个输入连接到128个隐藏神经元
print(f"W2 形状: {nn.W2.shape}")  # (128, 10)  —— 128个隐藏神经元连接到10个输出

# 模拟一张图片（784 个像素值，0-1 之间）
fake_image = np.random.rand(1, 784)
predictions = nn.forward(fake_image)
print(f"\n预测结果（10个数字的概率）:")
for i, prob in enumerate(predictions[0]):
    print(f"  数字 {i}: {prob:.4f}")
print(f"\n网络猜测这是数字: {np.argmax(predictions)}")

import torch
import torch.nn as nn

class SimpleNN(nn.Module):
    """与 1.5 节 NumPy 版本完全相同的三层神经网络"""
    def __init__(self):
        super(SimpleNN, self).__init__()

        self.fc1 = nn.Linear(784, 128)
        self.sigmoid = nn.Sigmoid()
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = self.sigmoid(x)
        x = self.fc2(x)
        return x

model = SimpleNN()
print(f"模型结构:\n{model}\n")

for name, param in model.named_parameters():
    print(f"{name}: {param.shape}")

fake_image = torch.randn(1, 784)
output = model(fake_image)

probs = torch.softmax(output, dim=1)
predicted = output.argmax(dim=1)

print(f"\n预测结果（10个数字的 logits）: {output}")
print(f"预测结果（10个数字的概率）: {probs}")
print(f"网络猜测这是数字: {predicted.item()}")