一天一个Python知识点——Day 155:神经网络基础

model.add(Dense(128, activation='relu'))

output = sign(w·x + b)

(0,0)→0, (0,1)→1, (1,0)→1, (1,1)→0  —— 没有一条直线能分开这四个点！

输入 → 线性变换 → 激活函数 → 线性变换 → 激活函数 → 输出

z = w₁x₁ + w₂x₂ + ... + wₙxₙ + ba = σ(z)

H = X @ W.T + b

import torchimport numpy as npdef matmul_naive(A, B):    """三层循环的矩阵乘法——每个Python程序员第一次写出的版本"""    m, n = A.shape    n, p = B.shape    C = torch.zeros(m, p)    for i in range(m):        for j in range(p):            for k in range(n):                C[i, j] += A[i, k] * B[k, j]    return Cdef matmul_better(A, B):    """去掉最内层循环——让PyTorch用C语言帮你做点积"""    m, n = A.shape    n, p = B.shape    C = torch.zeros(m, p)    for i in range(m):        for j in range(p):            C[i, j] = (A[i, :] * B[:, j]).sum()    return Cdef matmul_broadcast(A, B):    """利用广播——同时计算整行与矩阵的乘积"""    m, n = A.shape    n, p = B.shape    C = torch.zeros(m, p)    for i in range(m):        C[i, :] = (A[i, :].unsqueeze(1) * B).sum(dim=0)    return C# 测试：5张MNIST图片，展平成784维，映射到10个类别X = torch.randn(5, 784)W = torch.randn(10, 784)%time C1 = matmul_naive(X, W.T)%time C2 = matmul_better(X, W.T)%time C3 = matmul_broadcast(X, W.T)%time C4 = X @ W.T  # PyTorch的矩阵乘法

H = X @ W1 + b1O = H @ W2 + b2

O = (X @ W1 + b1) @ W2 + b2  = X @ (W1 @ W2) + (b1 @ W2 + b2)

σ(x) = 1 / (1 + e^{-x})输出范围：(0, 1)

tanh(x) = (e^x - e^{-x}) / (e^x + e^{-x})输出范围：(-1, 1)

ReLU(x) = max(0, x)

LeakyReLU(x) = max(αx, x), α通常取0.01

import numpy as npimport matplotlib.pyplot as pltx = np.linspace(-5, 5, 200)activations = {    'Sigmoid': lambda x: 1/(1+np.exp(-x)),    'Tanh': lambda x: np.tanh(x),    'ReLU': lambda x: np.maximum(0, x),    'Leaky ReLU': lambda x: np.where(x>0, x, 0.01*x)}fig, axes = plt.subplots(2, 2, figsize=(10, 8))for ax, (name, func) in zip(axes.flat, activations.items()):    y = func(x)    ax.plot(x, y, linewidth=2)    ax.axhline(y=0, color='k', linestyle=':', alpha=0.5)    ax.axvline(x=0, color='k', linestyle=':', alpha=0.5)    ax.set_title(f'{name}', fontweight='bold')    ax.grid(alpha=0.3)plt.suptitle('激活函数家族：线性世界的扭曲器', fontsize=14, fontweight='bold')plt.tight_layout()plt.show()

输入 x → 线性层 z = wx + b → 激活 a = σ(z) → 损失 L = ½(a - y)²

z = w*x + ba = σ(z)L = 0.5*(a - y)^2

dL/da = a - y

da/dz = σ(z) * (1 - σ(z))   # Sigmoid的导数

dL/dz = (dL/da) * (da/dz) = (a - y) * σ(z)*(1-σ(z))

dL/dw = dL/dz * dz/dw = dL/dz * xdL/db = dL/dz * dz/db = dL/dz * 1

w ← w - η * dL/dwb ← b - η * dL/db

import numpy as npclass Neuron:    def __init__(self, n_inputs):        self.w = np.random.randn(n_inputs) * 0.01        self.b = 0.0    def sigmoid(self, z):        return 1 / (1 + np.exp(-z))    def forward(self, x):        """前向：记住中间结果用于反向"""        self.x = x  # 缓存输入        self.z = np.dot(self.w, x) + self.b        self.a = self.sigmoid(self.z)        return self.a    def backward(self, dL_da):        """反向：链式法则"""        da_dz = self.a * (1 - self.a)      # sigmoid导数        dL_dz = dL_da * da_dz        dL_dw = dL_dz * self.x             # 权重梯度        dL_db = dL_dz * 1                  # 偏置梯度        # 如果需要传播给前一层        dL_dx = dL_dz * self.w        return dL_dw, dL_db, dL_dx    def update(self, dL_dw, dL_db, lr=0.1):        self.w -= lr * dL_dw        self.b -= lr * dL_db# 训练一个神经元np.random.seed(42)neuron = Neuron(3)# 假数据x = np.array([0.5, -0.2, 0.8])y_true = 1.0# 前向y_pred = neuron.forward(x)loss = 0.5 * (y_pred - y_true) ** 2# 反向dL_da = y_pred - y_truedL_dw, dL_db, _ = neuron.backward(dL_da)# 更新neuron.update(dL_dw, dL_db, lr=0.5)print(f"更新后权重: {neuron.w}")print(f"更新后偏置: {neuron.b:.4f}")

# 这是自杀w = np.zeros((n_inputs, n_neurons))b = np.zeros(n_neurons)

# He初始化（ReLU家族推荐）w = np.random.randn(n_inputs, n_neurons) * np.sqrt(2.0 / n_inputs)# Xavier初始化（Sigmoid/Tanh推荐）w = np.random.randn(n_inputs, n_neurons) * np.sqrt(1.0 / n_inputs)

import numpy as npclass Layer_Dense:    """全连接层：神经网络的基本积木"""    def __init__(self, n_inputs, n_neurons, activation='relu'):        # He初始化（ReLU专用）        self.weights = np.random.randn(n_inputs, n_neurons) * np.sqrt(2.0 / n_inputs)        self.biases = np.zeros(n_neurons)        self.activation_name = activation    def forward(self, inputs):        self.inputs = inputs  # 缓存用于反向传播        self.z = np.dot(inputs, self.weights) + self.biases        # 激活函数        if self.activation_name == 'relu':            self.output = np.maximum(0, self.z)        elif self.activation_name == 'sigmoid':            self.output = 1 / (1 + np.exp(-self.z))        elif self.activation_name == 'linear':            self.output = self.z        return self.output    def backward(self, dvalues):        """反向传播：计算梯度"""        self.dz = dvalues.copy()        # 激活函数的梯度        if self.activation_name == 'relu':            self.dz[self.z <= 0] = 0        elif self.activation_name == 'sigmoid':            sig = self.output            self.dz = self.dz * (sig * (1 - sig))        # 参数梯度        self.dweights = np.dot(self.inputs.T, self.dz)        self.dbiases = np.sum(self.dz, axis=0, keepdims=True).flatten()        # 传播给前一层的梯度        self.dinputs = np.dot(self.dz, self.weights.T)        return self.dinputs# 构建一个两层的神经网络class TwoLayerNet:    def __init__(self, input_size, hidden_size, output_size):        self.layer1 = Layer_Dense(input_size, hidden_size, 'relu')        self.layer2 = Layer_Dense(hidden_size, output_size, 'sigmoid')    def forward(self, X):        self.hidden = self.layer1.forward(X)        self.output = self.layer2.forward(self.hidden)        return self.output    def backward(self, dloss):        d2 = self.layer2.backward(dloss)        d1 = self.layer1.backward(d2)    def update(self, lr=0.01):        self.layer2.weights -= lr * self.layer2.dweights        self.layer2.biases -= lr * self.layer2.dbiases        self.layer1.weights -= lr * self.layer1.dweights        self.layer1.biases -= lr * self.layer1.dbiasesprint("全连接层实现完成！")print("你现在拥有了一个可以解决XOR问题的神经网络")