机器学习第五章-神经网络

import numpy as np
 
# 定义sigmoid函数及其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
 
def sigmoid_derivative(x):
    return x * (1 - x)
 
# 定义神经网络类
class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重
        self.weights_input_hidden = np.random.randn(input_size, hidden_size)
        self.weights_hidden_output = np.random.randn(hidden_size, output_size)
 
    def forward(self, inputs):
        # 前向传播
        self.hidden_input = np.dot(inputs, self.weights_input_hidden)
        self.hidden_output = sigmoid(self.hidden_input)
        self.output = sigmoid(np.dot(self.hidden_output, self.weights_hidden_output))
        return self.output
 
    def backward(self, inputs, targets, learning_rate):
        # 反向传播
        output_error = targets - self.output
        output_delta = output_error * sigmoid_derivative(self.output)
 
        hidden_error = output_delta.dot(self.weights_hidden_output.T)
        hidden_delta = hidden_error * sigmoid_derivative(self.hidden_output)
 
        # 更新权重
        self.weights_hidden_output += self.hidden_output.T.dot(output_delta) * learning_rate
        self.weights_input_hidden += inputs.T.dot(hidden_delta) * learning_rate
 
    def train(self, inputs, targets, epochs, learning_rate):
        for epoch in range(epochs):
            for i in range(len(inputs)):
                output = self.forward(inputs[i])
                self.backward(inputs[i], targets[i], learning_rate)
            if epoch % 1000 == 0:
                print(f"Epoch {epoch}: Error = {np.mean(np.square(targets - self.forward(inputs)))}")
 
# 示例用法
if __name__ == "__main__":
    # 输入数据和对应的标签（二分类问题）
    inputs = np.array([[0, 0],
                       [0, 1],
                       [1, 0],
                       [1, 1]])
 
    targets = np.array([[0], [1], [1], [0]])
 
    # 创建神经网络实例
    neural_network = NeuralNetwork(input_size=2, hidden_size=4, output_size=1)
 
    # 训练神经网络
    neural_network.train(inputs, targets, epochs=10000, learning_rate=0.1)
 
    # 测试神经网络（示例输出）
    test_inputs = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
    for input in test_inputs:
        print(f"Input: {input}, Predicted Output: {neural_network.forward(input)}")

        下面实验代码演示了如何使用梯度下降算法来寻找一个函数的全局最小值和局部最小值。这里假设我们要优化的函数是一个简单的二次函数 :

import numpy as np
import matplotlib.pyplot as plt
 
# 定义函数及其导数
def f(x):
    return x**4 - 3*x**3 + 2
 
def f_derivative(x):
    return 4*x**3 - 9*x**2
 
# 梯度下降算法找到最小值
def gradient_descent(starting_point, learning_rate, epochs):
    x = starting_point
    for epoch in range(epochs):
        gradient = f_derivative(x)
        x = x - learning_rate * gradient
    return x, f(x)
 
# 寻找全局最小值
global_min_point, global_min_value = gradient_descent(starting_point=0.0, learning_rate=0.01, epochs=1000)
 
# 寻找局部最小值（不同初始点）
local_min_point1, local_min_value1 = gradient_descent(starting_point=-1.0, learning_rate=0.01, epochs=1000)
local_min_point2, local_min_value2 = gradient_descent(starting_point=2.0, learning_rate=0.01, epochs=1000)
 
# 输出结果
print(f"Global Minimum: Point = {global_min_point}, Value = {global_min_value}")
print(f"Local Minimum 1: Point = {local_min_point1}, Value = {local_min_value1}")
print(f"Local Minimum 2: Point = {local_min_point2}, Value = {local_min_value2}")
 
# 绘制函数图像及最小值点
x = np.linspace(-2, 3, 400)
y = f(x)
 
plt.figure(figsize=(10, 6))
plt.plot(x, y, label='f(x) = x^4 - 3x^3 + 2')
plt.scatter(global_min_point, global_min_value, color='red', label='Global Minimum')
plt.scatter(local_min_point1, local_min_value1, color='green', label='Local Minimum 1')
plt.scatter(local_min_point2, local_min_value2, color='orange', label='Local Minimum 2')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Gradient Descent to Find Global and Local Minima')
plt.legend()
plt.grid(True)
plt.show()

5.5其他常见的神经网络

5.5.1RBF网络

        RBF网络是一种单隐层前馈神经网络，假定输入为 d维向量x，输出为实值， RBF 网络可表示为：

        通常采用两步过程来训练 RBF 网络:第一步，确定神经元中心常用的方式包括随机采样、聚类等;第二步，利用 BP 算法等来确定参数和.

5.5.2ART网络

        ART网络是竞争型学习的重要代表，该网络由比较层、识别层、识别阈值和重置模块构成.其中，比较层负责输入样本，并将其传递给识别层神经元.识别层每个神经元对应一个模式类，神经元数目可在训练过程中动态增长以增加新的模式类.

        它通过两个主要机制实现自适应：一是保持稳定的识别和分类能力，即当新输入到达时，网络可以调整自身以适应新模式，而不会完全改变已有的学习；二是在学习过程中通过比较新输入与已有模式的相似性来决定是否创建新的类别或更新现有类别。这使得ART网络在处理动态变化的数据和实时学习中具有较好的鲁棒性和适应性。

5.5.3SOM网络

        SOM 的训练过程很简单:在接收到一个训练样本后.每个输出层神经局会计算该样本与自身携带的权向量之间的距离，距离最近的神经元成为竞争获胜者，称为最佳匹配单元。 然后，最佳匹配单元及其邻近神经元的权向量将被调整，以使得这些权向量与当前输入样本的距离缩小.这个过 程不断迭代，直至收敛.

        ​​​​​​​        ​​​​​​​        

5.5.4级联相关网络

        结构自适网络是将网络结构也当作学习的目标之一。并希望能在训练过程中找到最符合数据特点 的网络结构。级联相关网络就是结构自适应网络的代表，其训练过程如下：

        与一般的前馈神经网络相比，级联相关网络无需设置网络层数、隐层神经元数目，且训练速度较快，但其在数据较小时易陷入过拟合。

5.5.5Elman网络

        Elman 网络它的结构与多层前馈网络很相似，但隐层神经元的输出被反馈回来，与下一时刻输入层神经元提供的信号一起，作为隐层神经元在下一时刻的输入：

        ​​​​​​​        ​​​​​​​        ​​​​​​​        

5.5.6Boltzmann 机

        神经网络中有一类模型是为网络状态定义一个“能量”，能量最小化时网络达到理想状态，而网络的训练就是在最小化这个能量函数。Boltzmann机就是一种“基于能量的模型”常见结构如图 其神经元分为两层:显层与隐层。显层用于表示数据的输入与输出，隐层则被理解为数据的内在表达。Boltzmann 机中的神经元都是布尔型的，即只能取 0、1两种状态，状态1表示激活，状态0表示抑制。

        ​​​​​​​        ​​​​​​​