PSO优化的BP神经网络——python实现

自己写的，编程渣渣，写的很乱，但也基本实现了，仅供参考。有朋友可以联系我相互讨论学习，

import math
import random
import numpy as np
random.seed（0）
def rand（a b）:
    return （b - a） * random.random（） + a

def make_matrix（m n fill=0.0）:
    mat = []
    for i in range（m）:
        mat.append（[fill] * n）
    return mat

def sigmoid（x）:
    return 1.0 / （1.0 + math.exp（-x））

def sigmoid_derivative（x）:
    return x * （1 - x）

class BPNeuralNetwork:
    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
        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）
        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）:
            print（inputs[i]）
            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 predict1（self inputsinput_weightsoutput_weights）:
        # activate input layer
        for i in range（self.input_n - 1）:
            print（inputs[i]）
            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] * input_weights[i][j]
            self.hidden_cells[j] = sigmoid（total）
        # activate output layer
        for k in range（self.output_n）:
       

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----

     文件       5841  2019-03-08 14:36  PSO_BP\bp.py

     文件       3637  2019-03-08 14:41  PSO_BP\pso_1.py

     文件        117  2019-03-08 16:59  PSO_BP\新建文本文档.txt

     目录          0  2019-03-08 16:57  PSO_BP

----------- ---------  ---------- -----  ----

                 9595                    4