简单多层神经网络示例代码

TriNeuron.py

#!/bin/env python3
# -*-coding:utf-8-*-

import math

from kubernetes.HiddenNeuron import HiddenNeuron
from kubernetes.InputNeuron import InputNeuron
from kubernetes.OutputNeuron import OutputNeuron


class TriNeuron:

    input_neurons = dict()
    hidden_neurons = dict()
    output_neurons = dict()
    alpha = 0.1
    training_set = []
    weights = dict()

    def __init__(self, training_set, weights, input_neurons, hidden_neurons, output_neurons, learning_speed=0.1):
        self.alpha = learning_speed
        self.training_set = training_set
        self.weights = weights
        self.input_neurons = input_neurons
        self.hidden_neurons = hidden_neurons
        self.output_neurons = output_neurons

    def training(self):

        done = False
        times = 0
        while not done:
            times = times + 1
            for set in self.training_set:
                y3 = self.sigmoid(set[0] * self.weights[1][3] + set[1] * self.weights[2][3] - self.hidden_neurons[3].thet)
                y4 = self.sigmoid(set[0] * self.weights[1][4] + set[1] * self.weights[2][4] - self.hidden_neurons[4].thet)
                y5 = self.sigmoid(y3 * self.weights[3][5] + y4 * self.weights[4][5] - self.output_neurons[5].thet)

                e = set[2] - y5

                if e ** 2 <= 0.00001:
                    done = True
                    break

                error_gradien_5 = y5 * (1 - y5) * e

                delta_weight_35 = self.alpha * y3 * error_gradien_5
                delta_weight_45 = self.alpha * y4 * error_gradien_5
                delta_thet_5 = self.alpha * -1 * error_gradien_5

                error_gradien_3 = y3 * (1 - y3) * error_gradien_5 * self.weights[3][5]
                delta_weight_13 = self.alpha * set[0] * error_gradien_3
                delta_weight_23 = self.alpha * set[1] * error_gradien_3
                delta_thet_3 = self.alpha * -1 * error_gradien_3

                error_gradien_4 = y4 * (1 - y4) * error_gradien_5 * self.weights[4][5]
                delta_weight_14 = self.alpha * set[0] * error_gradien_4
                delta_weight_24 = self.alpha * set[1] * error_gradien_4
                delta_thet_4 = self.alpha * -1 * error_gradien_4

                self.weights[1][3] = self.weights[1][3] + delta_weight_13
                self.weights[1][4] = self.weights[1][4] + delta_weight_14
                self.weights[2][3] = self.weights[2][3] + delta_weight_23
                self.weights[2][4] = self.weights[2][4] + delta_weight_24
                self.weights[3][5] = self.weights[3][5] + delta_weight_35
                self.weights[4][5] = self.weights[4][5] + delta_weight_45

                self.hidden_neurons[3].thet = self.hidden_neurons[3].thet + delta_thet_3
                self.hidden_neurons[4].thet = self.hidden_neurons[4].thet + delta_thet_4
                self.output_neurons[5].thet = self.output_neurons[5].thet + delta_thet_5
        else:
            print()
            print(times)
            print()

    def do_predict(self, sample):
        y3 = self.sigmoid(sample[0] * self.weights[1][3] + sample[1] * self.weights[2][3] - self.hidden_neurons[3].thet)
        y4 = self.sigmoid(sample[0] * self.weights[1][4] + sample[1] * self.weights[2][4] - self.hidden_neurons[4].thet)
        y5 = self.sigmoid(y3 * self.weights[3][5] + y4 * self.weights[4][5] - self.output_neurons[5].thet)
        return y5

    @staticmethod
    def sigmoid(x):
        return 1/(1+math.exp(-x))


if __name__ == '__main__':

    training_set = [(0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)]
    weights = {1: {3: 0.5, 4: 0.9}, 2: {3: 0.4, 4: 1.0}, 3: {5: -1.2}, 4: {5: 1.1}}

    input_neurons = dict()
    input_neurons[1] = InputNeuron(0, 1)
    input_neurons[2] = InputNeuron(1, 2)

    hidden_neurons = dict()
    hidden_neurons[3] = HiddenNeuron(0.8, 0, 3)
    hidden_neurons[4] = HiddenNeuron(-0.1, 1, 4)

    output_neurons = dict()
    output_neurons[5] = OutputNeuron(0.3, 0, 5)
    triNeuron = TriNeuron(training_set, weights, input_neurons, hidden_neurons, output_neurons)

    triNeuron.training()
    print()
    print('do predict')

    print(triNeuron.do_predict((0, 0)))
    print(triNeuron.do_predict((0, 1)))
    print(triNeuron.do_predict((1, 0)))
    print(triNeuron.do_predict((1, 1)))

InputNeuron.py

#!/bin/env python3
# -*-coding:utf-8-*-


class InputNeuron:
    index = 1
    index_all = 1

    def __init__(self, index, index_all):
        self.index = index
        self.index_all = index_all

    def __str__(self):
        return f"[index:{round(self.index,2)},index_all:{self.index_all}]"

HiddenNeuron.py

#!/bin/env python3
# -*-coding:utf-8-*-

from decimal import Decimal


class HiddenNeuron:
    thet = Decimal(0)
    hidden_val = -1
    index = 1
    index_all = 1

    def __init__(self, thet, index, index_all):
        self.thet = thet
        self.index = index
        self.index_all = index_all

    def __str__(self):
        return f"[thet:{self.thet}, index:{self.index}, index_all:{self.index_all}]"

OutputNeuron.py

#!/bin/env python3
# -*-coding:utf-8-*-


from kubernetes.HiddenNeuron import HiddenNeuron


class OutputNeuron(HiddenNeuron):

    def __init__(self, thet, index, index_all):
        HiddenNeuron.__init__(self, thet, index, index_all)