Python 实现一个全连接的神经网络

以下是实现一个全连接神经网络的完整攻略：

1. 确定神经网络的结构

神经网络的结构包括输入层、隐藏层和输出层。我们需要确定它们的神经元数量和激活函数。

假设输入层有n个神经元，隐藏层有m个神经元，输出层有k个神经元，我们可以选择用sigmoid或ReLU作为激活函数来实现神经网络。

2. 准备数据

神经网络的训练需要大量的数据。需要将数据进行预处理和分割为训练集、验证集和测试集。

3. 初始化神经网络参数

初始化各个神经元的权重和偏置。可以采用随机初始化方式来确保网络不落入局部极小值。

4. 计算每一层的输出

通过前向传递计算每一层的输出结果。即，输入数据被传递到第一个隐藏层，然后通过每一层的权重和偏置进行计算，最终得到输出结果。

5. 计算误差

计算输出层和真实值之间的误差。可以采用交叉熵损失函数或均方误差函数来计算误差。

6. 反向传播

通过反向传播算法来计算各个神经元的梯度，从而调整权重和偏置，以使神经网络减小误差。

7. 更新网络参数

更新权重和偏置的值，以使神经网络不断地学习和优化。

下面看两个示例：

示例一：实现一个全连接神经网络对鸢尾花进行分类

我们使用Python的scikit-learn库中的鸢尾花数据集来训练和测试神经网络，以下是具体的步骤：

导入必要的库和数据集

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import numpy as np

# 导入数据集
iris = load_iris()
X, y = iris.data, iris.target

# 将目标值转换为one-hot编码
y_one_hot = np.zeros((y.size, y.max()+1))
y_one_hot[np.arange(y.size), y] = 1

定义神经网络结构

class NeuralNetwork:
    def __init__(self, input_nodes, hidden_nodes, output_nodes):
        self.input_nodes = input_nodes
        self.hidden_nodes = hidden_nodes
        self.output_nodes = output_nodes

        # 初始化权重和偏置
        self.weights_1 = np.random.normal(0.0, self.hidden_nodes**-0.5, 
                                         (self.hidden_nodes, self.input_nodes))
        self.weights_2 = np.random.normal(0.0, self.output_nodes**-0.5, 
                                         (self.output_nodes, self.hidden_nodes))

        self.bias_1 = np.zeros((self.hidden_nodes, 1))
        self.bias_2 = np.zeros((self.output_nodes, 1))

        self.learning_rate = 0.1

        # 定义激活函数
        self.activation_function = lambda x : 1/(1 + np.exp(-x))

训练和测试神经网络

def train_nn(nn, X_train, y_train, epochs=1000):
    for e in range(epochs):
        # 前向传播
        hidden_input = np.dot(nn.weights_1, X_train.T) + nn.bias_1
        hidden_output = nn.activation_function(hidden_input)

        final_input = np.dot(nn.weights_2, hidden_output) + nn.bias_2
        final_output = nn.activation_function(final_input)

        # 计算误差
        error = y_train.T - final_output

        # 反向传播
        output_error_term = error * final_output * (1 - final_output)

        hidden_error = np.dot(nn.weights_2.T, output_error_term)
        hidden_error_term = hidden_error * hidden_output * (1 - hidden_output)

        # 更新权重和偏置
        nn.weights_2 += nn.learning_rate * np.dot(output_error_term, hidden_output.T)
        nn.bias_2 += nn.learning_rate * output_error_term.sum(axis=1).reshape(-1, 1)

        nn.weights_1 += nn.learning_rate * np.dot(hidden_error_term, X_train)
        nn.bias_1 += nn.learning_rate * hidden_error_term.sum(axis=1).reshape(-1, 1)

    # 预测并计算准确率
    hidden = nn.activation_function(np.dot(nn.weights_1, X_test.T) + nn.bias_1)
    predictions = nn.activation_function(np.dot(nn.weights_2, hidden) + nn.bias_2)
    y_pred = np.argmax(predictions, axis=0)
    accuracy = (y_pred == y_test).sum() / y_test.size

    return nn, accuracy

# 划分数据集并进行训练和测试
X_train, X_test, y_train, y_test = train_test_split(X, y_one_hot, test_size=0.2, random_state=42)
nn = NeuralNetwork(4, 10, 3)
nn, accuracy = train_nn(nn, X_train, y_train, epochs=1000)
print(f"Accuracy: {accuracy}")

示例二：实现一个全连接神经网络对手写数字进行分类

我们使用Python的scikit-learn库中的手写数字数据集来训练和测试神经网络，以下是具体的步骤：

导入必要的库和数据集

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
import numpy as np

# 导入数据集
digits = load_digits()
X, y = digits.data, digits.target

# 将目标值转换为one-hot编码
y_one_hot = np.zeros((y.size, y.max()+1))
y_one_hot[np.arange(y.size), y] = 1

定义神经网络结构

class NeuralNetwork:
    def __init__(self, input_nodes, hidden_nodes, output_nodes):
        self.input_nodes = input_nodes
        self.hidden_nodes = hidden_nodes
        self.output_nodes = output_nodes

        # 初始化权重和偏置
        self.weights_1 = np.random.normal(0.0, self.hidden_nodes**-0.5, 
                                         (self.hidden_nodes, self.input_nodes))
        self.weights_2 = np.random.normal(0.0, self.output_nodes**-0.5, 
                                         (self.output_nodes, self.hidden_nodes))

        self.bias_1 = np.zeros((self.hidden_nodes, 1))
        self.bias_2 = np.zeros((self.output_nodes, 1))

        self.learning_rate = 0.2

        # 定义激活函数
        self.activation_function = lambda x : 1/(1 + np.exp(-x))

训练和测试神经网络

def train_nn(nn, X_train, y_train, epochs=1000):
    for e in range(epochs):
        # 前向传播
        hidden_input = np.dot(nn.weights_1, X_train.T) + nn.bias_1
        hidden_output = nn.activation_function(hidden_input)

        final_input = np.dot(nn.weights_2, hidden_output) + nn.bias_2
        final_output = nn.activation_function(final_input)

        # 计算误差
        error = y_train.T - final_output

        # 反向传播
        output_error_term = error * final_output * (1 - final_output)

        hidden_error = np.dot(nn.weights_2.T, output_error_term)
        hidden_error_term = hidden_error * hidden_output * (1 - hidden_output)

        # 更新权重和偏置
        nn.weights_2 += nn.learning_rate * np.dot(output_error_term, hidden_output.T)
        nn.bias_2 += nn.learning_rate * output_error_term.sum(axis=1).reshape(-1, 1)

        nn.weights_1 += nn.learning_rate * np.dot(hidden_error_term, X_train)
        nn.bias_1 += nn.learning_rate * hidden_error_term.sum(axis=1).reshape(-1, 1)

    # 预测并计算准确率
    hidden = nn.activation_function(np.dot(nn.weights_1, X_test.T) + nn.bias_1)
    predictions = nn.activation_function(np.dot(nn.weights_2, hidden) + nn.bias_2)
    y_pred = np.argmax(predictions, axis=0)
    accuracy = (y_pred == y_test).sum() / y_test.size

    return nn, accuracy

# 划分数据集并进行训练和测试
X_train, X_test, y_train, y_test = train_test_split(X, y_one_hot, test_size=0.2, random_state=42)
nn = NeuralNetwork(64, 100, 10)
nn, accuracy = train_nn(nn, X_train, y_train, epochs=10000)
print(f"Accuracy: {accuracy}")

希望以上的攻略可以帮助你了解如何实现一个全连接的神经网络。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Python 实现一个全连接的神经网络 - Python技术站