BPNN

import random
import math
random.seed(0)

def rand(b, a):
    return (b-a)*random.random()+a


def make_matrix(m,  n,  fill=0.0):  # 创造一个指定大小的矩阵
    mat = []

    print([fill]*10)
    for i in range(m):
        mat.append([fill] * n)
    return mat


def sigmoid(x):
    return 1.0 / (1.0+math.exp(-x))


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


class Bpnn:
    def __init__(self):
        self.input_n = 0
        self.hidden_n = 0
        self.output_n = 0
        self.input_cells = []
        self.hidden_cells = []
        self.output_cells = []
        self.input_weights = []
        self.output_weights = []
        self.input_correction = []
        self.output_correction = []


    def setup(self, ni,  nh, no):
        self.input_n = ni + 1    # input 神经元数
        self.hidden_n = nh      # 隐藏层神经元数
        self.output_n = no      # 输出层神经元数
        # init cells
        self.input_cells = [1.0] * self.input_n  #
        self.hidden_cells = [1.0] * self.hidden_n
        self.output_cells = [1.0] * self.output_n
        # init weights
        self.input_weights = make_matrix(self.input_n,  self.hidden_n)  # 0 矩阵
        self.output_weights = make_matrix(self.hidden_n,  self.output_n)
        # random activate
        for i in range(self.input_n):
            for h in range(self.hidden_n):
                self.input_weights[i][h] = rand(-0.2,  0.2)
        for h in range(self.hidden_n):
            for o in range(self.output_n):
                self.output_weights[h][o] = rand(-2.0, 2.0)
        # init correction matrix
        self.input_correction = make_matrix(self.input_n,  self.hidden_n)
        self.output_correction = make_matrix(self.hidden_n,  self.output_n)


    def predict(self,  inputs):
        # activate input layer
        for i in range(self.input_n - 1):
            self.input_cells[i] = inputs[i]
        # activate hidden layer
        for j in range(self.hidden_n):
            total = 0.0
            for i in range(self.input_n):
                total += self.input_cells[i] * self.input_weights[i][j]
            self.hidden_cells[j] = sigmoid(total)

        # activate output layer
        for k in range(self.output_n):
            total = 0.0
            for j in range(self.hidden_n):
                total += self.hidden_cells[j] * self.output_weights[j][k]
            self.output_cells[k] = sigmoid(total)
        return self.output_cells[:]

    def back_propagate(self,  case,  label,  learn,  correct):
        # feed forward
        self.predict(case)
        # get output layer error
        output_deltas = [0.0] * self.output_n
        for o in range(self.output_n):
            error = label[o] - self.output_cells[o]
            output_deltas[o] = sigmod_derivate(self.output_cells[o]) * error
        # get hidden layer error
        hidden_deltas = [0.0] * self.hidden_n
        for h in range(self.hidden_n):
            error = 0.0
            for o in range(self.output_n):
                error += output_deltas[o] * self.output_weights[h][o]
            hidden_deltas[h] = sigmod_derivate(self.hidden_cells[h]) * error
        # update output weights
        for h in range(self.hidden_n):
            for o in range(self.output_n):
                change = output_deltas[o] * self.hidden_cells[h]
                self.output_weights[h][o] += learn * change + correct * self.output_correction[h][o]
                self.output_correction[h][o] = change
        # update input weights
        for i in range(self.input_n):
            for h in range(self.hidden_n):
                change = hidden_deltas[h] * self.input_cells[i]
                self.input_weights[i][h] += learn * change + correct * self.input_correction[i][h]
                self.input_correction[i][h] = change
        # get global error
        error = 0.0
        for o in range(len(label)):
            error += 0.5 * (label[o] - self.output_cells[o]) ** 2
        return error

    def train(self,  cases,  labels,  limit=10000,  learn=0.05,  correct=0.1):
        for i in range(limit):
            error = 0.0
            for i in range(len(cases)):
                label = labels[i]
                case = cases[i]
                error += self.back_propagate(case,  label,  learn, correct)

    def tests(self):

        cases = [
                [0, 0],
                [0, 1],
                [1, 0],
                [1, 1],
            ]
        labels = [[0],  [1],  [1], [0]]
        self.setup(2,  5,  1)
        self.train(cases,  labels,  10000,  0.05,  0.1)
        for case in cases:
            print(self.predict(case))


if __name__ == '__main__':
     mm = Bpnn()
     mm.tests()

### Python 中 BPNN 的实现与使用 反向传播神经网络(Backpropagation Neural Network, BPNN)是一种基于误差逆传播算法训练的前馈人工神经网络。以下是关于如何在 Python 中实现或使用 BPNN 的详细介绍。 #### 使用 `TensorFlow` 或 `Keras` 实现 BPNN 现代深度学习框架如 TensorFlow 和 Keras 提供了简单易用的接口来构建和训练 BPNN 模型。以下是一个简单的例子: ```python import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense # 创建模型 model = Sequential([ Dense(10, activation='relu', input_shape=(input_dim,)), # 输入层到隐藏层 Dense(8, activation='relu'), # 隐藏层 Dense(output_dim, activation='softmax') # 输出层 ]) # 编译模型 model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) # 训练模型 model.fit(X_train, y_train, epochs=50, batch_size=32) # 测试模型 test_loss, test_acc = model.evaluate(X_test, y_test) print(f'Test accuracy: {test_acc}') ``` 此代码片段展示了如何通过 Keras 构建一个具有两层隐藏层的 BPNN 并对其进行训练[^1]。 #### 手动实现 BPNN 如果希望更深入理解 BPNN 工作原理,可以手动编写其核心逻辑。下面展示了一个简化版本的手动实现过程: ```python import numpy as np def sigmoid(x): return 1 / (1 + np.exp(-x)) def sigmoid_derivative(x): return x * (1 - x) # 初始化参数 np.random.seed(1) weights_hidden = 2 * np.random.random((input_dim, hidden_dim)) - 1 bias_hidden = 2 * np.random.random((1, hidden_dim)) - 1 weights_output = 2 * np.random.random((hidden_dim, output_dim)) - 1 bias_output = 2 * np.random.random((1, output_dim)) - 1 for iteration in range(iterations): # 前向传播 layer_input = X layer_hidden = sigmoid(np.dot(layer_input, weights_hidden) + bias_hidden) layer_output = sigmoid(np.dot(layer_hidden, weights_output) + bias_output) # 反向传播 error_output = y - layer_output delta_output = error_output * sigmoid_derivative(layer_output) error_hidden = delta_output.dot(weights_output.T) delta_hidden = error_hidden * sigmoid_derivative(layer_hidden) # 更新权重和偏置 weights_output += layer_hidden.T.dot(delta_output) bias_output += np.sum(delta_output, axis=0, keepdims=True) weights_hidden += layer_input.T.dot(delta_hidden) bias_hidden += np.sum(delta_hidden, axis=0, keepdims=True) ``` 这段代码实现了基本的 BPNN 结构及其训练流程[^2]。 #### 科学计算资源推荐 对于更多科学计算工具包以及扩展功能的支持,可参考 SciPy Central 网站上的软件列表[^1]。这些库能够提供额外的功能支持,帮助优化 BPNN 性能。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值