import math
import random
import numpy
import os

random.seed(0)

# gera numeros aleatorios obedecendo a regra:  a <= rand < b
def criar_linha():
    print("-",80)

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

# nossa funcao sigmoide - gera graficos em forma de S
# funcao tangente hiperbolica
def funcao_ativacao_tang_hip(x):
    return math.tanh(x)

# derivada da tangente hiperbolica
def derivada_funcao_ativacao(x):
    t = funcao_ativacao_tang_hip(x)
    return 1 - t**2

class RedeNeural:
    def __init__(self, nos_entrada, nos_ocultos, nos_saida):
        # camada de entrada
        self.nos_entrada = nos_entrada + 1 # +1 por causa do no do bias
        # camada oculta
        self.nos_ocultos = nos_ocultos
        # camada de saida
        self.nos_saida = nos_saida
        # quantidade maxima de interacoes
        self.max_interacoes = 1000
        # taxa de aprendizado
        self.taxa_aprendizado = 0.5

        # activations for nodes
        # cria uma matriz, preenchida com uns, de uma linha pela quantidade de nos
        self.ativacao_entrada = numpy.ones(self.nos_entrada)
        self.ativacao_ocultos = numpy.ones(self.nos_ocultos)
        self.ativacao_saida = numpy.ones(self.nos_saida)

        # contém os resultados das ativações de saída
        self.resultados_ativacao_saida = numpy.ones(self.nos_saida)

        # criar a matriz de pesos, preenchidas com zeros
        self.wi = numpy.zeros((self.nos_entrada, self.nos_ocultos))
        self.wo = numpy.zeros((self.nos_ocultos, self.nos_saida))

        # adicionar os valores dos pesos
        # vetor de pesos da camada de entrada - intermediaria
        for i in range(self.nos_entrada):
            for j in range(self.nos_ocultos):
                self.wi[i][j] = rand(-0.2, 0.2)

        # vetor de pesos da camada intermediaria - saida
        for j in range(self.nos_ocultos):
            for k in range(self.nos_saida):
                self.wo[j][k] = rand(-2.0, 2.0)

    def fase_forward(self, entradas):
        # input activations: -1 por causa do bias
        for i in range(self.nos_entrada - 1):
            self.ativacao_entrada[i] = entradas[i]

        # calcula as ativacoes dos neuronios da camada escondida
        for j in range(self.nos_ocultos):
            soma = 0
            for i in range(self.nos_entrada):
                soma = soma + self.ativacao_entrada[i] * self.wi[i][j]
            self.ativacao_ocultos[j] = funcao_ativacao_tang_hip(soma)

        # calcula as ativacoes dos neuronios da camada de saida
        # Note que as saidas dos neuronios da camada oculta fazem o papel de entrada
        # para os neuronios da camada de saida.
        for j in range(self.nos_saida):
            soma = 0
            for i in range(self.nos_ocultos):
                soma = soma + self.ativacao_ocultos[i] * self.wo[i][j]
            self.ativacao_saida[j] = funcao_ativacao_tang_hip(soma)

        return self.ativacao_saida


    def fase_backward(self, saidas_desejadas):
        # calcular os gradientes locais dos neuronios da camada de saida
        output_deltas = numpy.zeros(self.nos_saida)
        erro = 0
        for i in range(self.nos_saida):
            erro = saidas_desejadas[i] - self.ativacao_saida[i]
            output_deltas[i] = derivada_funcao_ativacao(self.ativacao_saida[i]) * erro

        # calcular os gradientes locais dos neuronios da camada escondida
        hidden_deltas = numpy.zeros(self.nos_ocultos)
        for i in range(self.nos_ocultos):
            erro = 0
            for j in range(self.nos_saida):
                erro = erro + output_deltas[j] * self.wo[i][j]
            hidden_deltas[i] = derivada_funcao_ativacao(self.ativacao_ocultos[i]) * erro

        # a partir da ultima camada ate a camada de entrada
        # os nos da camada atual ajustam seus pesos de forma a reduzir seus erros
        for i in range(self.nos_ocultos):
            for j in range(self.nos_saida):
                change = output_deltas[j] * self.ativacao_ocultos[i]
                self.wo[i][j] = self.wo[i][j] + (self.taxa_aprendizado * change)

        # atualizar os pesos da primeira camada
        for i in range(self.nos_entrada):
            for j in range(self.nos_ocultos):
                change = hidden_deltas[j] * self.ativacao_entrada[i]
                self.wi[i][j] = self.wi[i][j] + (self.taxa_aprendizado * change)


        # calcula erro
        erro = 0
        for i in range(len(saidas_desejadas)):
            erro = erro + 0.5 * (saidas_desejadas[i] - self.ativacao_saida[i]) ** 2
        return erro

    def test(self, entradas_saidas):
        for p in entradas_saidas:
            array = self.fase_forward(p[0])
            print("Entradas: " + str(p[0]) + ' - Saída encontrada/fase forward: ' + str(array[0]))

    def treinar(self, entradas_saidas):
        for i in range(self.max_interacoes):
            erro = 0
            for p in entradas_saidas:
                entradas = p[0]
                saidas_desejadas = p[1]
                self.fase_forward(entradas)
                erro = erro + self.fase_backward(saidas_desejadas)
            if i % 100 == 0:
                print("Erro = %2.3f",erro)


def iniciar():

	# Ensinar a rede a reconhecer o padrao XOR
    entradas_saidas = [
                      [[ -0.02 , 0.94 ], [ 0.999955780327 ]],
                      [[ 0.07 , -0.9 ], [ 0.999959010293 ]],
                      [[ -0.34 , 0.3 ], [ 0.999983940189 ]],
                      [[ 0.24 , 0.03 ], [ 0.999994195033 ]],
                      [[ -0.23 , 0.22 ], [ 0.999992290042 ]],
                      [[ -0.09 , 0.49 ], [ 0.999987185034 ]],
                      [[ -0.45 , 0.29 ], [ 0.999975545498 ]],
                      [[ -0.65 , -0.28 ], [ 0.999953831953 ]],
                      [[ -0.65 , 0.93 ], [ 0.999914508924 ]],
                      [[ -0.76 , 0.58 ], [ 0.999925424355 ]],
                      [[ -0.36 , 0.36 ], [ 0.999980560259 ]],
                      [[ 0.8 , 0.54 ], [ 0.999921425064 ]],
                      [[ -0.63 , -0.21 ], [ 0.999958106664 ]],
                      [[ -0.75 , 0.86 ], [ 0.999906775472 ]],
                      [[ -0.82 , 0.75 ], [ 0.999904641544 ]],
                      [[ -0.16 , 0.2 ], [ 0.999995440012 ]],
                      [[ 0.43 , -0.75 ], [ 0.999953385994 ]],
                      [[ -0.1 , 0.11 ], [ 0.999998395002 ]],
                      [[ -0.2 , 0.56 ], [ 0.99998032012 ]],
                      [[ 0.63 , -0.48 ], [ 0.999948792055 ]],
                      [[ 0.41 , 0.22 ], [ 0.999980770324 ]],
                      [[ 0.13 , 0.33 ], [ 0.999992865017 ]],
                      [[ -0.34 , -0.85 ], [ 0.999952315769 ]],
                      [[ 0.4 , -0.97 ], [ 0.999936956378 ]],
                      [[ -0.77 , 0.84 ], [ 0.999905435814 ]],
                      [[ 0.02 , 0.81 ], [ 0.999967155181 ]],
                      [[ 0.71 , 0.6 ], [ 0.999931593502 ]],
                      [[ -1.0 , 0.56 ], [ 0.999884331608 ]],
                      [[ 0.26 , -0.15 ], [ 0.999992115054 ]],
                      [[ -0.38 , 0.86 ], [ 0.99994858097 ]],
                      [[ -0.17 , 0.8 ], [ 0.999965110271 ]],
                      [[ -0.84 , -0.52 ], [ 0.999915925963 ]],
                      [[ 0.45 , -0.44 ], [ 0.999970070622 ]],
                      [[ -0.39 , -0.64 ], [ 0.999964310613 ]],
                      [[ 0.39 , 0.14 ], [ 0.999983810246 ]],
                      [[ -0.77 , -0.8 ], [ 0.999908715583 ]],
                      [[ -0.19 , 0.3 ], [ 0.999991890033 ]],
                      [[ 0.25 , -0.73 ], [ 0.999967105324 ]],
                      [[ -0.23 , 0.41 ], [ 0.999986305084 ]],
                      [[ -0.26 , 0.8 ], [ 0.999961240433 ]],
                      [[ -0.69 , 0.4 ], [ 0.999944392658 ]],
                      [[ -0.15 , 0.38 ], [ 0.99999053003 ]],
                      [[ -0.48 , 0.54 ], [ 0.999962380902 ]],
                      [[ 0.4 , 0.5 ], [ 0.999971500482 ]],
                      [[ -0.27 , 0.13 ], [ 0.999991865059 ]],
                      [[ -0.77 , 0.52 ], [ 0.999927194347 ]],
                      [[ -0.02 , -0.19 ], [ 0.999998155001 ]],
                      [[ 0.47 , -0.39 ], [ 0.999970305666 ]],
                      [[ -0.26 , -0.53 ], [ 0.999979195174 ]],
                      [[ -0.52 , -0.53 ], [ 0.999958916144 ]],
                      [[ -0.92 , 0.56 ], [ 0.999899688531 ]],
                      [[ 0.68 , -0.34 ], [ 0.999947982411 ]],
                      [[ 0.21 , -0.83 ], [ 0.999961145369 ]],
                      [[ -0.78 , 0.73 ], [ 0.999912520441 ]],
                      [[ 0.93 , -0.67 ], [ 0.999891074505 ]],
                      [[ -0.62 , -0.91 ], [ 0.999920158355 ]],
                      [[ -0.8 , 0.79 ], [ 0.999904801255 ]],
                      [[ 0.38 , 0.74 ], [ 0.999958180729 ]],
                      [[ 0.0 , 0.8 ], [ 0.999968000171 ]],
                      [[ 0.34 , -0.3 ], [ 0.999983940189 ]],
                      [[ 0.33 , -0.4 ], [ 0.999981110216 ]],
                      [[ -0.45 , 0.73 ], [ 0.999953106068 ]],
                      [[ 0.5 , 0.07 ], [ 0.999974755631 ]],
                      [[ 0.48 , -0.3 ], [ 0.999972460638 ]],
                      [[ 0.15 , 0.26 ], [ 0.999994370015 ]],
                      [[ 0.69 , 0.64 ], [ 0.999931913312 ]],
                      [[ 0.79 , -0.09 ], [ 0.99993718892 ]],
                      [[ -0.79 , -0.17 ], [ 0.999936148985 ]],
                      [[ 0.56 , -0.71 ], [ 0.99994343688 ]],
                      [[ 0.24 , 0.5 ], [ 0.999981740131 ]],
                      [[ 0.61 , -0.15 ], [ 0.999961666427 ]],
                      [[ -0.52 , -0.38 ], [ 0.999965740935 ]],
                      [[ -0.96 , 0.87 ], [ 0.999870007219 ]],
                      [[ -0.31 , -0.71 ], [ 0.99996518544 ]],
                      [[ 0.8 , -0.44 ], [ 0.999926324731 ]],
                      [[ -0.05 , -0.57 ], [ 0.999983505048 ]],
                      [[ -0.15 , 0.09 ], [ 0.999997345006 ]],
                      [[ -0.85 , -0.75 ], [ 0.999899632383 ]],
                      [[ -0.63 , 0.78 ], [ 0.999929892937 ]],
                      [[ -0.44 , -0.89 ], [ 0.999941036403 ]],
                      [[ 0.46 , 0.62 ], [ 0.999959620916 ]],
                      [[ 0.36 , 0.54 ], [ 0.999972460392 ]],
                      [[ 0.74 , -0.82 ], [ 0.999911625028 ]],
                      [[ -0.94 , -0.69 ], [ 0.999887845004 ]],
                      [[ 0.62 , -0.52 ], [ 0.999948042028 ]],
                      [[ 0.55 , 0.47 ], [ 0.999958706269 ]],
                      [[ -0.7 , 0.0 ], [ 0.999951002401 ]],
                      [[ -0.77 , -0.06 ], [ 0.999940533526 ]],
                      [[ -0.71 , -0.91 ], [ 0.999908189914 ]],
                      [[ 0.55 , -0.95 ], [ 0.999924627619 ]],
                      [[ -0.51 , -0.53 ], [ 0.999959946075 ]],
                      [[ 0.83 , -0.69 ], [ 0.99990731148 ]],
                      [[ 0.22 , -0.47 ], [ 0.999984115097 ]],
                      [[ 0.86 , -0.85 ], [ 0.999889923359 ]],
                      [[ 0.73 , -0.95 ], [ 0.999901590584 ]],
                      [[ 0.39 , 0.08 ], [ 0.999984470236 ]],
                      [[ 0.58 , -0.75 ], [ 0.99993823721 ]],
                      [[ -0.34 , -0.83 ], [ 0.99995399573 ]],
                      [[ -0.44 , -0.82 ], [ 0.999947021214 ]],
                      [[ 0.65 , -0.23 ], [ 0.999955106898 ]]
    ]

    # cria rede neural com duas entradas, duas ocultas e um no de saida
    n = RedeNeural(2, 2, 1)
    criar_linha()
    # treinar com os padrões
    n.treinar(entradas_saidas)
    # testar
    criar_linha()
    n.test(entradas_saidas)

if __name__ == '__main__':
    iniciar()