import math
import random
import numpy
import os

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 ]]
    ]

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

# camada de entrada
nos_entrada = 2
nos_entrada = nos_entrada + 1 # +1 por causa do no do bias
# camada oculta
nos_ocultos = 30
# camada de saida
nos_saida = 1
# quantidade maxima de interacoes
max_interacoes = 1000
# taxa de aprendizado
taxa_aprendizado = 0.5

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

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

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

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

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

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

# calcula as ativacoes dos neuronios da camada escondida
    for j in range(nos_ocultos):
        soma = 0
        for i in range(nos_entrada):
            soma = soma + ativacao_entrada[i] * wi[i][j]
        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(nos_saida):
        soma = 0
        for i in range(nos_ocultos):
            soma = soma + ativacao_ocultos[i] * wo[i][j]
        ativacao_saida[j] = funcao_ativacao_tang_hip(soma)

    return ativacao_saida

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

# calcular os gradientes locais dos neuronios da camada escondida
    hidden_deltas = numpy.zeros(nos_ocultos)
    for i in range(nos_ocultos):
        erro = 0
        for j in range(nos_saida):
            erro = erro + output_deltas[j] * wo[i][j]
        hidden_deltas[i] = derivada_funcao_ativacao(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(nos_ocultos):
        for j in range(nos_saida):
            change = output_deltas[j] * ativacao_ocultos[i]
            wo[i][j] = wo[i][j] + (taxa_aprendizado * change)

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


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

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

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


def iniciar():
# cria rede neural com duas entradas, duas ocultas e um no de saida
    criar_linha()
    treinar(entradas_saidas)
    # testar
    criar_linha()
    test(entradas_saidas)

iniciar()