博客

下面是Python实现的人工神经网络算法示例【基于反向传播算法】的完整攻略：

算法简介

人工神经网络算法是模拟人脑神经元之间相互联接的计算系统，通过对大量的数据进行学习训练，实现对未知数据的识别、分类或预测等任务。其中反向传播算法是一种基于梯度下降算法的学习算法，通过不断调整网络的权重和偏置值，使得损失函数的值最小化，从而达到对数据进行拟合的目的。

算法实现

1.数据预处理

在实现反向传播算法之前，需要对数据进行预处理，包括数据的归一化、分割为训练集和测试集等步骤。

# 加载数据
def load_data(file_path):
    data,labels = [],[]
    with open(file_path,'r') as f:
        for line in f.readlines():
            line = line.strip().split(',')
            data.append([float(x) for x in line[1:]])
            labels.append(int(line[0]))
    return np.array(data),np.array(labels)

# 归一化数据
def normalize_data(data):
    return (data - np.mean(data,axis=0)) / np.std(data,axis=0)

# 分割数据集
def split_data(data,labels,train_ratio=0.8):
    n_samples = len(labels)
    n_train = int(n_samples*train_ratio)
    shuffle_index = np.random.permutation(n_samples)
    train_index = shuffle_index[:n_train]
    test_index = shuffle_index[n_train:]
    return data[train_index],labels[train_index],data[test_index],labels[test_index]

file_path = 'data/digits.csv'
data,labels = load_data(file_path)
data = normalize_data(data)
x_train,y_train,x_test,y_test = split_data(data,labels)

2.定义网络结构

在实现反向传播算法之前，需要先定义神经网络的结构，包括层数、每层神经元的数量和激活函数等参数，本例中定义了一个包含两个隐藏层的全连接神经网络。

class NeuralNetwork:

    def __init__(self,input_dim,hidden_dims,output_dim):
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.hidden_dims = hidden_dims
        self.weights = []
        self.biases = []
        self.activations = []

        # 初始化权重和偏置值
        dims = [input_dim] + hidden_dims + [output_dim]
        for i in range(len(dims)-1):
            self.weights.append(np.random.randn(dims[i],dims[i+1]))
            self.biases.append(np.random.randn(dims[i+1]))
            self.activations.append(self.sigmoid)

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

    # 前向传播
    def forward(self,x):
        self.zs = []
        self.activations_values = [x]
        for i in range(len(self.weights)):
            z = np.dot(self.activations_values[i],self.weights[i]) + self.biases[i]
            self.zs.append(z)
            activation = self.activations[i](z)
            self.activations_values.append(activation)
        return self.activations_values[-1]

    # 计算损失函数
    def loss(self,y_pred,y_true):
        return np.sum((y_pred - y_true)**2)

    # 反向传播
    def backward(self,x,y_true):
        # 计算输出层的误差
        y_pred = self.forward(x)
        delta_output = (y_pred - y_true) * y_pred * (1 - y_pred)

        # 计算隐藏层的误差
        deltas = [delta_output]
        for i in range(len(self.weights)-1,-1,-1):
            delta = np.dot(deltas[-1],self.weights[i].T) * self.activations[i](self.zs[i],derivative=True)
            deltas.append(delta)
        deltas.reverse()

        # 更新权重和偏置值
        for i in range(len(self.weights)):
            self.weights[i] -= self.learning_rate * np.dot(self.activations_values[i].T,deltas[i])
            self.biases[i] -= self.learning_rate * np.sum(deltas[i],axis=0)

3.训练模型

定义好神经网络结构之后，就可以开始训练模型了，训练模型的过程是通过多次迭代，不断调整权重和偏置值的值，使得损失函数的值逐渐减小，达到可接受的误差范围后结束训练。

# 定义训练过程
def train(model,x_train,y_train,batch_size=100,learning_rate=0.01,epochs=10):
    n_samples = len(y_train)
    n_batches = int(n_samples / batch_size)
    model.learning_rate = learning_rate

    # 迭代训练epoch次
    for i in range(epochs):
        print('Epoch: {}/{}'.format(i+1,epochs))
        shuffle_index = np.random.permutation(n_samples)

        # 对每个batch进行训练
        for j in range(n_batches):
            # 获取当前batch的数据
            batch_index = shuffle_index[j*batch_size:(j+1)*batch_size]
            x_batch = x_train[batch_index]
            y_batch = y_train[batch_index]

            # 进行反向传播，更新权重和偏置值
            model.backward(x_batch,y_batch)

        # 每个epoch结束后打印损失函数的值
        y_pred = model.forward(x_train)
        loss = model.loss(y_pred,y_train)
        print('Loss: {}'.format(loss))

# 创建神经网络模型
model = NeuralNetwork(input_dim=64,hidden_dims=[50,20],output_dim=10)

# 训练模型
train(model,x_train,y_train,batch_size=100,learning_rate=0.01,epochs=10)

4.测试模型

最后一步是用测试集数据测试训练好的模型，统计模型在测试集上的准确率和损失函数值等指标，以评估模型的性能。

# 定义测试过程
def test(model,x_test,y_test):
    y_pred = model.forward(x_test)
    pred_labels = np.argmax(y_pred,axis=1)
    true_labels = y_test
    accuracy = np.sum(pred_labels==true_labels) / len(true_labels)
    loss = model.loss(y_pred,y_test)
    print('Accuracy: {:.2f}%'.format(accuracy*100))
    print('Loss: {}'.format(loss))

# 测试模型
test(model,x_test,y_test)

示例1：手写数字识别

下面是手写数字识别的例子，训练样本使用的是MNIST数据集，该数据集包含大约6万张28×28的图片，每张图片表示一个手写数字，训练集和测试集的比例为8:2，目标是对测试集的手写数字进行识别。

# 加载数据
from sklearn.datasets import fetch_openml
mnist = fetch_openml('mnist_784',version=1)
data = mnist.data / 255.
labels = mnist.target.astype(int)

# 归一化、分割数据集
data = normalize_data(data)
x_train,y_train,x_test,y_test = split_data(data,labels)

# 创建神经网络模型
model = NeuralNetwork(input_dim=784,hidden_dims=[256,128],output_dim=10)

# 训练模型
train(model,x_train,y_train,batch_size=100,learning_rate=0.01,epochs=10)

# 测试模型
test(model,x_test,y_test)

示例2：鸢尾花分类

下面是鸢尾花分类的例子，样本数据使用的是iris数据集，该数据集包含150个样本，每个样本包含4个特征值，分别为花萼长度、花萼宽度、花瓣长度和花瓣宽度，样本分为三类鸢尾花，目标是对新的样本进行分类。

# 加载数据
from sklearn.datasets import load_iris
iris = load_iris()
data = iris.data
labels = iris.target

# 归一化、分割数据集
data = normalize_data(data)
x_train,y_train,x_test,y_test = split_data(data,labels)

# 创建神经网络模型
model = NeuralNetwork(input_dim=4,hidden_dims=[5,3],output_dim=3)

# 训练模型
train(model,x_train,y_train,batch_size=10,learning_rate=0.01,epochs=10)

# 测试模型
test(model,x_test,y_test)

以上就是Python实现的人工神经网络算法示例【基于反向传播算法】的完整攻略。