import numpy as np
from numpy.random import *
import pickle

class FNeuron:
    friends = np.array([])
    w = np.array([])
    cur_sum = 0.0
    storage = 0.0
#------------------------------
    def __init__(self,netSize):
        self.w = np.zeros(netSize)
        self.friends = np.zeros(netSize)
        self.cur_sum = 0.0
#------------------------------
    def AddLink(self,j):
        self.w[j] = random_sample()
        self.friends[j] = True
#---------------------------------------------------------------------------------------
class NeuralNet:
    net = np.array([])
    delta = np.array([])
    I,N,K = 0, 0, 0
    netSize = 0

    speed,eps = 0, 0
    feedforward_prob = 0.75
    feedback_prob = 0.4
    selfconn_prob = 0.3
    new_link_prob = 0.0005
#------------------------------
    def __init__(self,I,N,K,speed,eps):
        self.I = I
        self.N = N
        self.K = K

        self.netSize = I + N + K
        self.net = []
        self.speed = speed
        self.eps = eps

        for i in range(self.netSize):
            temp = FNeuron(self.netSize)
            self.net.append(temp)
        self.delta = np.zeros(self.netSize)
        self.GenerateNet()
#------------------------------
    def GenerateNet(self):
        for i in range(self.I + self.N):
            for j in range(self.netSize):
                p = random_sample()
                if (p <= self.feedforward_prob and i < j):
                    self.net[i].AddLink(j)

        i = self.I + self.N + self.K - 1
        while(i >= 0):
            for j in range(self.netSize):
                p = random_sample()
                if(p <= self.feedback_prob and i > j):
                    self.net[i].AddLink(j)
            i -= 1

        i = self.I
        j = self.I
        while(i < self.I + self.N):
            p = random_sample()
            if(p <= self.selfconn_prob and i == j):
                self.net[i].AddLink(j)
            i+=1
            j+=1
#------------------------------
    def Sigmoid(self,x):
        return 1 / (1 + np.exp(-x))
#------------------------------
    def Compute(self, vector):
        for i in range(self.netSize):
            self.net[i].cur_sum = 0.0

        for i in range(len(vector)):
            self.net[i].cur_sum = vector[i]

        i = self.I
        while(i < self.netSize):
            val = 0.0
            tmp = 0.0
            for j in range(self.netSize):
                if(self.net[j].friends[i] and j < i):
                    val += self.net[j].w[i] * self.net[j].cur_sum
                elif(self.net[j].friends[i] and j >= i):
                    tmp += self.net[j].w[i] * self.net[j].cur_sum

            self.net[i].cur_sum = self.Sigmoid(val) + self.net[i].storage
            self.net[i].storage = tmp
            i+=1

        result = np.zeros(self.K)
        for i in range(self.K):
            result[i] = self.net[self.I + self.N + i].cur_sum
        return result
#------------------------------
    def BackPropagation(self, vector, optim):
        self.Compute(vector)

        for i in range(self.I + self.N, self.netSize):
            yi = self.net[i].cur_sum
            val = 0.0
            for j in range(self.netSize):
                if(self.net[i].friends[j]):
                    val += self.delta[j] * self.net[i].w[j]

            self.delta[i] = ((optim[i - self.I - self.N] - yi) + val) * yi * (1 - yi)

            for j in range(self.netSize):
                if(self.net[j].friends[i]):
                    self.net[j].w[i] += self.speed * self.delta[i] * self.net[j].cur_sum

        i = self.I + self.N - 1
        while(i >= self.I):
            val = 0
            for j in range(self.netSize):
                if(self.net[i].friends[j]):
                    val += self.delta[j] * self.net[i].w[j]

            yi = self.net[i].cur_sum
            self.delta[i] = val * yi * (1 - yi)

            for j in range(self.netSize):
                if(self.net[j].friends[i]):
                    self.net[j].w[i] += self.speed * self.delta[i] * self.net[j].cur_sum

            i -= 1
#------------------------------
    def IsLearned(self,y,opt):
        max = 0.0
        n = len(y[0])
        for q in range(len(y)):
            for i in range(n):
                if (abs(opt[q][i] - y[q][i]) > max):
                    max = abs(opt[q][i] - y[q][i])
        if(max >= self.eps):return False
        return True
#------------------------------
    def Training(self, vectors, opt, maxIter=0, exit_on_epochs=False):
        for i in range(len(self.delta)):
            self.delta[i] = 0

        y = []

        for i in range(len(vectors)):
            y.append(self.Compute(vectors[i]))

        cur_epoch = 0
        while(not self.IsLearned(y,opt)):
            cur_epoch += 1
            if(cur_epoch >= maxIter and exit_on_epochs):
                return cur_epoch

            for i in range(len(vectors)):
                self.BackPropagation(vectors[i], opt[i])

            for i in range(len(vectors)):
                y[i] = self.Compute(vectors[i])

        self.New_Link()
        return cur_epoch
#------------------------------
    def New_Link(self):
        p = random_sample()
        if(p <= self.new_link_prob):
            for i in range(self.netSize):
                for j in range(self.netSize):
                    if(not self.net[i].friends[j]):
                        self.net[i].AddLink(j)
                        return
#------------------------------
    def PrintLinks(self):
        for i in range(self.netSize):
            for j in range(self.netSize):
                if(self.net[i].friends[j]):
                    print "1",
                else:
                    print "0",
            print
#---------------------------------------------------------------------------------------
net = NeuralNet(2, 10, 1, 0.3, 0.03)
vec = []
res = []

for i in  range(10):
    for j in range(10):
        vec.append([i,j])
        if (i == j):
            res.append([1])
        else:
            res.append([0])

a = net.Training(vec, res)

for i in range(15):
    for j in range(15):
        print i," ",j," ",
        print net.Compute([i,j])

print a
net.PrintLinks()