神经网络

模型：

感知机（二层）

感知机是最简单的神经网络，只有输入层和输出层，激活函数放在输出层里

激活函数(线性函数)： 1.ReLU（z）=max（0，z） 2.sigmoid:用于输出概率值 3.softmax:用于多分类任务，将输出转化为概率分布

bp神经网络（三层以上）

除了输入层和输出层，还有中间隐藏层，放置多个激活函数

优化权重，bp（方向传播优化），常见方法：梯度下降，牛顿法

import numpy as np

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

def sigmoid_derivative(x):
    return x * (1 - x)

# 创建一个简单的神经网络类
class SimpleNeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重和偏置
        self.weights_input_hidden = np.random.uniform(-1, 1, (input_size, hidden_size))
        self.weights_hidden_output = np.random.uniform(-1, 1, (hidden_size, output_size))
        self.bias_hidden = np.random.uniform(-1, 1, (1, hidden_size))
        self.bias_output = np.random.uniform(-1, 1, (1, output_size))

    def forward(self, X):
        # 前向传播
        self.hidden_layer = sigmoid(np.dot(X, self.weights_input_hidden) + self.bias_hidden)
        self.output_layer = sigmoid(np.dot(self.hidden_layer, self.weights_hidden_output) + self.bias_output)
        return self.output_layer

    def backward(self, X, y, learning_rate):
        # 计算损失梯度
        output_error = y - self.output_layer
        output_delta = output_error * sigmoid_derivative(self.output_layer)

        hidden_error = np.dot(output_delta, self.weights_hidden_output.T)
        hidden_delta = hidden_error * sigmoid_derivative(self.hidden_layer)

        # 更新权重和偏置
        self.weights_hidden_output += np.dot(self.hidden_layer.T, output_delta) * learning_rate
        self.bias_output += np.sum(output_delta, axis=0, keepdims=True) * learning_rate
        self.weights_input_hidden += np.dot(X.T, hidden_delta) * learning_rate
        self.bias_hidden += np.sum(hidden_delta, axis=0, keepdims=True) * learning_rate

    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            self.forward(X)
            self.backward(X, y, learning_rate)
            if (epoch + 1) % 100 == 0:
                loss = np.mean((y - self.output_layer) ** 2)
                print(f"Epoch {epoch + 1}, Loss: {loss}")

# 创建数据
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  # 输入
y = np.array([[0], [1], [1], [0]])  # 输出（XOR问题）

# 初始化网络
input_size = 2
hidden_size = 4
output_size = 1
nn = SimpleNeuralNetwork(input_size, hidden_size, output_size)

# 训练网络
nn.train(X, y, epochs=10000, learning_rate=0.1)

# 测试
predictions = nn.forward(X)
print("Predictions:")
print(predictions)