用Python神经网络做预测，训练出来的权值和阈值都是nan值，误差越训练越大，求解？

梯度爆炸了吧

这问题我遇到过，八成是梯度爆炸了。NaN值出现通常是因为计算过程中数值溢出，比如激活函数输入值太大导致指数运算溢出。

给你个能跑的解决方案：

import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重 - 使用Xavier初始化防止梯度爆炸
        self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2.0 / input_size)
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(2.0 / hidden_size)
        self.b2 = np.zeros((1, output_size))
    
    def relu(self, x):
        return np.maximum(0, x)
    
    def forward(self, X):
        # 前向传播
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.relu(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        return self.z2  # 回归问题用线性输出
    
    def train(self, X, y, learning_rate=0.001, epochs=1000):
        m = X.shape[0]
        
        for epoch in range(epochs):
            # 前向传播
            output = self.forward(X)
            
            # 计算损失 - 用MSE
            loss = np.mean((output - y) ** 2)
            
            # 反向传播
            d_output = 2 * (output - y) / m
            
            # 梯度裁剪 - 防止梯度爆炸的关键
            d_output = np.clip(d_output, -1, 1)
            
            dW2 = np.dot(self.a1.T, d_output)
            db2 = np.sum(d_output, axis=0, keepdims=True)
            
            d_a1 = np.dot(d_output, self.W2.T)
            d_a1[self.a1 <= 0] = 0  # ReLU导数
            
            dW1 = np.dot(X.T, d_a1)
            db1 = np.sum(d_a1, axis=0, keepdims=True)
            
            # 更新参数
            self.W1 -= learning_rate * dW1
            self.b1 -= learning_rate * db1
            self.W2 -= learning_rate * dW2
            self.b2 -= learning_rate * db2
            
            if epoch % 100 == 0:
                print(f"Epoch {epoch}, Loss: {loss:.6f}")
        
        return self.W1, self.b1, self.W2, self.b2

# 使用示例
if __name__ == "__main__":
    # 生成示例数据
    np.random.seed(42)
    X = np.random.randn(100, 3)
    y = np.random.randn(100, 1)
    
    # 数据标准化 - 很重要！
    X = (X - np.mean(X, axis=0)) / np.std(X, axis=0)
    y = (y - np.mean(y)) / np.std(y)
    
    # 创建和训练网络
    nn = NeuralNetwork(input_size=3, hidden_size=5, output_size=1)
    weights = nn.train(X, y, learning_rate=0.01, epochs=1000)
    
    print("\n训练完成，权重非NaN验证:")
    for name, param in zip(['W1', 'b1', 'W2', 'b2'], weights):
        print(f"{name}: 包含NaN值 - {np.any(np.isnan(param))}")

核心就三件事：权重用Xavier初始化、数据必须标准化、梯度记得裁剪。学习率从0.01开始试，大了容易炸。

标准化数据，初始化权重，裁剪梯度。