使用numpy实现神经网络

实现神经网络可以分为以下几个步骤：

1. 初始化参数：定义神经网络的层数、每层的神经元数量和参数权重，一般采用随机初始化。
2. 前向传播：计算每层的线性变换和激活函数输出，得到最终的输出结果。
3. 计算损失函数：使用交叉熵损失函数来评估模型预测结果和实际结果的差距。
4. 反向传播：计算每个参数对损失函数的梯度，更新权重参数，使损失函数减小。
5. 训练模型：反复进行前向传播和反向传播，更新权重参数，使损失函数最小化，得到最终的优化模型。

以下是使用numpy实现神经网络的示例代码：

import numpy as np

# 定义神经网络的参数
input_size = 2
hidden_size = 3
output_size = 1
learning_rate = 0.1

# 随机初始化神经网络的权重
W1 = np.random.randn(input_size, hidden_size)
b1 = np.zeros((1, hidden_size))
W2 = np.random.randn(hidden_size, output_size)
b2 = np.zeros((1, output_size))

# 定义激活函数sigmoid
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 定义损失函数交叉熵
def cross_entropy_loss(y_pred, y_true):
    return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))

# 定义前向传播函数
def forward(x):
    z1 = np.dot(x, W1) + b1
    a1 = sigmoid(z1)
    z2 = np.dot(a1, W2) + b2
    y_pred = sigmoid(z2)
    return y_pred, (x, z1, a1, z2, y_pred)

# 定义反向传播函数
def backward(y_pred, y_true, cache):
    x, z1, a1, z2, y_pred = cache
    delta2 = (y_pred - y_true) * y_pred * (1 - y_pred)
    dW2 = np.dot(a1.T, delta2)
    db2 = np.sum(delta2, axis=0, keepdims=True)
    delta1 = np.dot(delta2, W2.T) * a1 * (1 - a1)
    dW1 = np.dot(x.T, delta1)
    db1 = np.sum(delta1, axis=0)
    return dW1, db1, dW2, db2

# 定义训练函数
def train(X, y):
    y_pred, cache = forward(X)
    loss = cross_entropy_loss(y_pred, y)
    dW1, db1, dW2, db2 = backward(y_pred, y, cache)
    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1
    W2 -= learning_rate * dW2
    b2 -= learning_rate * db2
    return loss

# 测试代码
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
for i in range(10000):
    loss = train(X, y)
    if i % 1000 == 0:
        print("Epoch {}: loss = {}".format(i, loss))
y_pred, _ = forward(X)
print("Predictions: ", y_pred)

这段代码实现了一个包含1个隐藏层的神经网络，使用交叉熵损失函数进行优化，最终输出结果为每个样本的二分类概率。