用python实现bp神经网络算法

以下是使用Python实现BP神经网络算法的步骤：

1.导入必要的库

import numpy as np

2.定义sigmoid函数

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

3.初始化权重和偏置

def init_weights(layer_sizes):
    weights = []
    biases = []
    for i in range(len(layer_sizes) - 1):
        w = np.random.randn(layer_sizes[i], layer_sizes[i+1])
        b = np.zeros((1, layer_sizes[i+1]))
        weights.append(w)
        biases.append(b)
    return weights, biases

4.前向传播

def forward_propagation(X, weights, biases):
    a = X
    activations = [a]
    zs = []
    for i in range(len(weights)):
        z = np.dot(a, weights[i]) + biases[i]
        a = sigmoid(z)
        zs.append(z)
        activations.append(a)
    return activations, zs

5.计算代价函数

def compute_cost(Y, Y_hat):
    m = Y.shape[0]
    cost = -1/m * np.sum(Y * np.log(Y_hat) + (1-Y) * np.log(1-Y_hat))
    return cost

6.反向传播

def backward_propagation(X, Y, weights, biases, activations, zs):
    m = Y.shape[0]
    dA = -(np.divide(Y, activations[-1]) - np.divide(1 - Y, 1 - activations[-1]))
    dZ = dA * sigmoid(zs[-1]) * (1 - sigmoid(zs[-1]))
    dW = 1/m * np.dot(activations[-2].T, dZ)
    db = 1/m * np.sum(dZ, axis=0, keepdims=True)
    dA_prev = np.dot(dZ, weights[-1].T)
    dWs = [dW]
    dbs = [db]
    for i in range(len(weights) - 2, -1, -1):
        dZ = dA_prev * sigmoid(zs[i]) * (1 - sigmoid(zs[i]))
        dW = 1/m * np.dot(activations[i].T, dZ)
        db = 1/m * np.sum(dZ, axis=0, keepdims=True)
        dA_prev = np.dot(dZ, weights[i].T)
        dWs.append(dW)
        dbs.append(db)
    dWs.reverse()
    dbs.reverse()
    return dWs, dbs

7.更新权重和偏置

def update_weights(weights, biases, dWs, dbs, alpha):
    for i in range(len(weights)):
        weights[i] -= alpha * dWs[i]
        biases[i] -= alpha * dbs[i]
    return weights, biases

8.训练模型

def train(X, Y, layer_sizes, alpha, epochs):
    weights, biases = init_weights(layer_sizes)
    for i in range(epochs):
        activations, zs = forward_propagation(X, weights, biases)
        cost = compute_cost(Y, activations[-1])
        dWs, dbs = backward_propagation(X, Y, weights, biases, activations, zs)
        weights, biases = update_weights(weights, biases, dWs, dbs, alpha)
        if i % 100 == 0:
            print("Epoch {}: cost = {}".format(i, cost))
    return weights, biases

9.使用模型进行预测

def predict(X, weights, biases):
    activations, zs = forward_propagation(X, weights, biases)
    predictions = (activations[-1] > 0.5).astype(int)
    return predictions