import math
import random

"""	Нейронная сеть.
	Количество нейронов в слое и количество самих слоёв задаётся пользователем.
	Функцией активации является сигмоида.
"""

def startLearning(G, V, NN, numAfterComma, learningRate, testCases):
	""" Главная функция обучения сети,
			из-под которой вызываются все остальные.
	"""
	clearNeuronValues(V)		#Очищаем все values в нейронах от предыдущего прохода.
	for x,y,z,expected in testCases:	#Считываем кортеж из 3-х входных значений
		portion = (x,y,z, expected)		#и одного правильного ответа (x,y,z, e).
		i = 0
		for v in V:		#Ищем сенсорные нейроны и записываем в них данные.
			if v[0:1] == '0':
				V[v]['value'] = portion[i]
				i += 1
		forwardRun(G, V, NN, numAfterComma)
		backwardRun(G, V, NN, numAfterComma, expected, learningRate)


def forwardRun(G, V, NN, numAfterComma):
	""" Прямой проход.
			Проходит все слои нейронов в прямом направлении
			и активирует их последовательно значениями,
			полученными от стартовых нейронов, помноженными
			на вес связей соответствующих нейронов, и проведёнными
			через функцию активации (сигмоид).

			Кортеж NN содержит наглядное представление
			слоёв нейронов. Индекс кортежа равен № слоя нейронов,
			значение индекса кортежа равно кол-ву нейронов
			в соответствующем слое.

			for vert in G:			#Имена вершин начинаются с цифры, равной № слоя.
			if vert[0:1] == str(i)	#Если она совпадает с индексом кортежа (т.е. с № слоя),
									#значит мы рассматриваем все нейроны данного слоя.
	"""
	for i in range(len(NN)-1):	#От O до предпоследнего слоя включительно.
		for vert in G:
			if vert[0:1] == str(i+1):	#Просматриваем нейроны нижнего слоя из верхнего:
				for v in G[vert]:		#со слоя I рассматриваем слой O, со слоя II - слой I.
					if v[0:1] == str(i):
						prevVelue = V[v]['value']		#Считываем value нижнего нейрона
						prevWeight = G[vert][v]			#и вес связи с текущим.
						V[vert]['value'] += prevVelue*prevWeight	#Суммируем в value верхнего нейрона.
				V[vert]['value'] = sigmoid(V[vert]['value'])		#По окончании цикла суммирования
				V[vert]['value'] = reduceSimbols(V[vert]['value'],	#активируем в сигмоиде и отбрасываем
													numAfterComma)	#лишние знаки после запятой.


def backwardRun(G, V, NN, numAfterComma, expected, learningRate):
	""" Обратный проход, используя
		Метод обратного распространения ошибок.

		Проходим все слои нейронов в обратном направлении,
		считаем ошибку выходного и всех нижележащих нейронов.
		Через ошибку вычисляем поправку на вес связи нейронов.

		Цикл от последнего слоя к O, т.е. все слои в обратном порядке.
		Рассматриваем 3 варианта бока (if -- elif -- elif):
		- если это самый верхний слой;
		- если это самый нижний слой;
		- если это скрытые слои.
	"""
	for i in range(len(NN)-1, -1, -1):	#От выходного слоя к O.
		for vert in G:
			if vert[0:1] == str(i) and i == len(NN)-1:	#Если это самый верхний слой.
				currentValue = V[vert]['value']
				currentSigma = firstSigma(expected, currentValue)
				V[vert]['sigma'] = currentSigma

			elif vert[0:1] == str(i) and i == 0:	#Если это самый нижний слой.
				currentValue = V[vert]['value']
				for v in G[vert]:
					if v[0:1] == str(i+1):	#Меняем веса из нижнего слоя в верхнем.
						weightOutOld, parentSigma = getParentInfo(G, vert, v, V)
						delta = calcDelta(currentValue, parentSigma, learningRate)
						weightOutNew = calcNewWeight(delta, weightOutOld)
						weightOutNew = reduceSimbols(weightOutNew, numAfterComma)
						writeNewWeight(G, vert, v, weightOutNew)

			elif vert[0:1] == str(i):	#Если это скрытый слой.
				currentValue = V[vert]['value']
				preSigma = 0
				for v in G[vert]:
					if v[0:1] == str(i+1):
						weightOutOld, parentSigma = getParentInfo(G, vert, v, V)
						delta = calcDelta(currentValue, parentSigma, learningRate)
						weightOutNew = calcNewWeight(delta, weightOutOld)
						weightOutNew = reduceSimbols(weightOutNew, numAfterComma)
						writeNewWeight(G, vert, v, weightOutNew)
						preSigma += weightOutOld*parentSigma
				currentSigma = preSigma*derivative(currentValue)
				V[vert]['sigma'] = currentSigma



def clearNeuronValues(V):	#Обнуляем все значения "value" в нейроне.
	for v in V:
		V[v]['value'] = 0


def writeNewWeight(G, vert, v,	#Записывает новый вес в граф.
					weightOutNew):
	G[vert][v] = weightOutNew
	G[v][vert] = weightOutNew


def getParentInfo(G, vert, v, V):	#Считывает ошибку и вес связи из
	weightOutOld = G[vert][v]		#нейрона и соединения пары нейронов.
	parentSigma = V[v]['sigma']
	return (weightOutOld, parentSigma)


def calcDelta(currentValue,		#Вычисление дельты
				parentSigma,	#веса связи.
				learningRate):
	delta = currentValue*parentSigma*learningRate
	return delta


def calcNewWeight(delta, weightOutOld):	#Вычисление нового веса связи
	weightOutNew = weightOutOld+delta 	#по старому и дельте.
	return weightOutNew


def firstSigma(expected,	#Вычисление ошибки самого верхнего нейрона.
				currentValue):
	sigma = (expected-currentValue)*derivative(currentValue)
	return sigma


def calcSigma(parentSigma,		#Вычисление ошибки нейронов
				weightOutOld,	#скрытого слоя.
				currentValue):
	sigma = parentSigma*weightOutOld*derivative(currentValue)
	return sigma


def derivative(value):		#Производная функции активации
	return value*(1-value)

def sigmoid(x):		#Функция активации
	return 1/(1+math.e**(-x))

def reduceSimbols(x, y):	#Оставляет Y знаков после запятой числа X.
	return int(x*10**y)/10**y


def createGraph(G, NN, numAfterComma):
	""" Создаёт структуру нейронной сети в виде графа,
			представленного словарём из словарей со значениями
			ключей внутреннего словаря в виде весов нейронных связей.
	"""
	for i in range(len(NN)-1): 	#Для каждого слоя, кроме последнего.
		nomberNeuronsInLayerLeft = NN[i]		#Считаем кол-во нейронов
		nomberNeuronsInLayerRight = NN[i+1]		#в слое.
		for x in range(nomberNeuronsInLayerLeft):
			nameVertexLeft = str(i)+str(x)				#Создаём имена нейронов каждого
			for y in range(nomberNeuronsInLayerRight):	#слоя так, чтобы имя нулевого слоя
				nameVertexRight = str(i+1)+str(y)		#начиналось с O, второго - с 1 и т.д.
				stdWeight = random.random()				#Рандомный вес от 0 до 1.
				stdWeight = reduceSimbols(stdWeight,	#Отбрасываем лишние
										numAfterComma)	#знаки после запятой.
				for v1,v2 in ((nameVertexLeft,nameVertexRight),
								(nameVertexRight,nameVertexLeft)):
					if v1 not in G:
						G[v1] = {v2 : stdWeight}
					else:
						G[v1][v2] = stdWeight
	print()
	print('Так выглядят в начале рандомные веса связей \
между нейронами сети')
	for v in G:
		print(v, G[v])
	print()


def main():
	NN = input('Введи через пробел число нейронов послойно \
	слева направо, начиная с сенсорных. Например, 3 2 1:').split()
	NN = [int(x) for x in NN]	#Было ['3','2','1']   стало [3,2,1]
	valuesOfNeuron = ('value', 'sigma')
	testCases = ((0,0,0,0), (0,0,1,1),	(0,1,0,0), (0,1,1,0),
				(1,0,0,1), (1,0,1,1), (1,1,0,0), (1,1,1,1))

	generation = 10000
	learningRate = 0.05
	numAfterComma = 10
	G = {}
	createGraph(G, NN, numAfterComma)
	V = {keys:{values:0 for values in valuesOfNeuron} for keys in G}

	while generation != 0:
		startLearning(G, V, NN, numAfterComma, learningRate, testCases)
		generation -= 1


if __name__ == '__main__':
	main()
    

1 час назад, Guard_of_world сказал: