Python人工神经网络（Artificial Neural Network）实现

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

class NeuralNetwork:
    def __init__(self, input_dim, output_dim, hidden_layers=[4]):
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.hidden_layers = hidden_layers
        self.weights = []
        self.bias = []
        cur_dim = input_dim
        for layer in hidden_layers:
            self.weights.append(np.random.normal(size=(cur_dim, layer)))
            self.bias.append(np.random.normal(size=(layer,)))
            cur_dim = layer
        self.weights.append(np.random.normal(size=(cur_dim, output_dim)))
        self.bias.append(np.random.normal(size=(output_dim,)))

    def forward(self, x):
        a = x
        for i in range(len(self.weights)):
            z = np.dot(a, self.weights[i]) + self.bias[i]
            a = 1 / (1 + np.exp(-z))
        return a

    def backpropagation(self, x, y, lr):
        a = [x]
        z = []
        for i in range(len(self.weights)):
            z.append(np.dot(a[i], self.weights[i]) + self.bias[i])
            a.append(1 / (1 + np.exp(-z[i])))
        delta = [-(y - a[-1]) * a[-1] * (1 - a[-1])]
        for i in range(len(self.weights) - 1, -1, -1):
            delta.append(np.dot(delta[-1], self.weights[i].T) * a[i] * (1 - a[i]))
        delta.reverse()
        for i in range(len(self.weights)):
            self.weights[i] -= lr * np.dot(a[i].T, delta[i])
            self.bias[i] -= lr * np.sum(delta[i], axis=0)

    def train(self, x, y, lr=0.01, epochs=1000, batch_size=None):
        loss_history = []
        for epoch in range(epochs):
            if batch_size is None:
                idx = np.arange(len(x))
            else:
                idx = np.random.choice(len(x), size=batch_size, replace=False)
            x_batch = x[idx]
            y_batch = y[idx]
            self.backpropagation(x_batch, y_batch, lr)
            loss = np.mean((self.forward(x_batch) - y_batch) ** 2)
            loss_history.append(loss)
            if epoch % 100 == 0:
                print(f"Epoch {epoch}, Loss {loss}")
        plt.plot(loss_history)
        plt.xlabel("Epoch")
        plt.ylabel("Loss")
        plt.show()

x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
model = NeuralNetwork(2, 1, [4])
model.train(x, y, lr=0.1, epochs=1000, batch_size=None)

print(model.forward(np.array([[0, 0], [0, 1], [1, 0], [1, 1]])))

[[0.02957606]
 [0.96548824]
 [0.9659576 ]
 [0.03649135]]