#!/bin/env python3
# -*-coding:utf-8-*-
# InputNeuron.py
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}]"
#!/bin/env python3
# -*-coding:utf-8-*-
# hiddenNeuron.py
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}]"
#!/bin/env python3
# -*-coding:utf-8-*-
# outputNeuron.py
from kubernetes.HiddenNeuron import HiddenNeuron
class OutputNeuron(HiddenNeuron):
def __init__(self, thet, index, index_all):
HiddenNeuron.__init__(self, thet, index, index_all)
#!/bin/env python3
# -*-coding:utf-8-*-
#triNeuron.py
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
beta = 0.95
training_set = []
weights = dict()
def __init__(self, training_set, weights, input_neurons, hidden_neurons, output_neurons, learning_speed=0.1, beta=1.0001):
self.alpha = learning_speed
self.beta = beta
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
delta_weight_13_last = 0
delta_weight_14_last = 0
delta_weight_35_last = 0
delta_weight_45_last = 0
delta_weight_23_last = 0
delta_weight_24_last = 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.001:
done = True
break
error_gradient_5 = y5 * (1 - y5) * e
if delta_weight_35_last == 0:
delta_weight_35_last = delta_weight_35 = self.alpha * y3 * error_gradient_5
else:
delta_weight_35_last= delta_weight_35 = self.beta * delta_weight_35_last + self.alpha * y3 * error_gradient_5
if delta_weight_45_last == 0:
delta_weight_45_last = delta_weight_45 = self.alpha * y4 * error_gradient_5
else:
delta_weight_45_last = delta_weight_45 = self.beta * delta_weight_45_last + self.alpha * y4 * error_gradient_5
delta_thet_5 = self.alpha * -1 * error_gradient_5
error_gradient_3 = y3 * (1 - y3) * error_gradient_5 * self.weights[3][5]
if 0 == delta_weight_13_last:
delta_weight_13_last = delta_weight_13 = self.alpha * set[0] * error_gradient_3
else:
delta_weight_13_last = delta_weight_13 = self.beta * delta_weight_13_last + self.alpha * set[0] * error_gradient_3
if 0 == delta_weight_23_last:
delta_weight_23_last = delta_weight_23 = self.alpha * set[1] * error_gradient_3
else:
delta_weight_23_last = delta_weight_23 = self.beta * delta_weight_23_last + self.alpha * set[1] * error_gradient_3
delta_thet_3 = self.alpha * -1 * error_gradient_3
error_gradient_4 = y4 * (1 - y4) * error_gradient_5 * self.weights[4][5]
if 0 == delta_weight_14_last:
delta_weight_14_last = delta_weight_14 = self.alpha * set[0] * error_gradient_4
else:
delta_weight_14_last = delta_weight_14 = self.beta * delta_weight_14_last + self.alpha * set[0] * error_gradient_4
if 0 == delta_weight_24_last:
delta_weight_24_last = delta_weight_24 = self.alpha * set[1] * error_gradient_4
else:
delta_weight_24_last = delta_weight_24 = self.beta * delta_weight_24_last + self.alpha * set[1] * error_gradient_4
delta_thet_4 = self.alpha * -1 * error_gradient_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("training times:" + str(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))
def __str__(self):
return ''
if __name__ == '__main__':
training_set = [(1, 1, 0), (0, 0, 0), (0, 1, 1), (1, 0, 1)]
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)))
来源：https://blog.csdn.net/QZFZZ/article/details/98735055