from math import *
import random

def sig(x):
    return 1 / (1 + exp(-x))

def sig_prime(x): # x already sigmoided
    return x * (1 - x)

def tanh_prime(x): # x already tanhed
    return 1 - x * x

def relu(x):
    return max(x,0)

def relu_prime(x): # x already relued
    return 1 if x > 0 else 0


class Network:
    def __init__(self, input_size, hidden_size, alpha, mom):
        self.hidden_size = hidden_size
        self.input_size = input_size
        self.input_weights = []
        self.input_biases = []
        self.output_weights = []
        self.output_bias = random.uniform(-0.5,0.5)
        self.input_momentum_weights = []
        self.output_momentum_weights = []
        self.alpha = alpha
        self.mom = mom
        for i in range(hidden_size):
            input_weight_list = []
            input_momentum_list = []

            for i in range(input_size):
                input_weight_list.append(random.uniform(-0.5,0.5))

            for i in range(input_size):
                input_momentum_list.append(0)

            self.input_weights.append(input_weight_list)
            self.input_biases.append(random.uniform(-0.5,0.5))
            self.output_weights.append(random.uniform(-0.5,0.5))
            self.input_momentum_weights.append(input_momentum_list)
            self.output_momentum_weights.append(0)

    def forward(self, inputs):
        h = [] # hidden node value
        for i in range(len(self.input_weights)):
            result = self.input_biases[i]
            for j in range(self.input_size):
                result += self.input_weights[i][j]*inputs[j]
            h.append(relu(result))
        o = 0 # output value
        for i in range(len(self.output_weights)):
            o += self.output_weights[i] * h[i]
        o += self.output_bias
        return tanh(o)

    def learn(self,inputs,t):
        h = [] # hidden node value
        for i in range(len(self.input_weights)):
            result = self.input_biases[i]
            for j in range(self.input_size):
                result += self.input_weights[i][j]*inputs[j]
            h.append(relu(result))
        o = 0 # output value
        for i in range(len(self.output_weights)):
            o += self.output_weights[i] * h[i]
        o += self.output_bias
        o = tanh(o)

        e = t - o

        do = e * tanh_prime(o)

        eh = []
        for i in range(len(self.output_weights)):
            eh.append(do * self.output_weights[i])

        dh = []
        for i in range(len(self.output_weights)):
            dh.append(eh[i] * relu_prime(h[i]))

        for i in range(len(self.output_weights)):
            self.output_momentum_weights[i] = self.mom * self.output_momentum_weights[i] + self.alpha * h[i] * do
            self.output_weights[i] += self.output_momentum_weights[i]
        self.output_bias += self.alpha * do

        for i in range(len(self.input_weights)):
            for j in range(self.input_size):
                self.input_momentum_weights[i][j] = self.mom * self.input_momentum_weights[i][j] + self.alpha * inputs[j] * dh[i]
            for j in range(self.input_size):
                self.input_weights[i][j] += self.input_momentum_weights[i][j]
            self.input_biases[i] += self.alpha * dh[i]