import numpy as np

class BackPropagationNetwork:

layerCount = 0
shape = None
weights = []


def __init__(self, layerSize):

    self.layerCount = len(layerSize) - 1
    self.shape = layerSize

    self._layerInput = []
    self._layerOutput = []

    for (l1,l2) in zip(layerSize[:-1], layerSize[1:]):
        self.weights.append(np.random.normal(scale = 0.005,size = (l2,l1+1)))

def Run(self, input):

    lnCases = input.shape[0]

    self._layerInput = []
    self._layerOutput = []

    for index in range(self.layerCount):
        if index == 0:
            layerInput = self.weights[0].dot(np.vstack([input.T,np.ones([1, lnCases])]))
        else:
            layerInput = self.weights[index].dot(np.vstack([self._layerOutput[-1],np.ones([1, lnCases])]))

        self._layerInput.append(layerInput)
        self._layerOutput.append(self.sgm(layerInput))

    return self._layerOutput[-1].T

def sgm(self, x, Derivative = False):   #the function
    if not Derivative:
        return np.maximum(0,x)
        #return np.tanh(x)
    else:
        x[x<=0] = 0
        x[x>0] = 1
        #return (1-(np.tanh(x))**2)
        return x


def TrainEpoch(self, input, target, trainingRate = 0.2):

    delta = []
    lnCases  = input.shape[0]

    self.Run(input)

    for index in reversed(range(self.layerCount)):
        if index == self.layerCount - 1:

            output_delta = self._layerOutput[index] - target.T
            error = np.sum(output_delta**2)
            delta.append(output_delta * self.sgm(self._layerInput[index],True))
        else:
            delta_pullback = self.weights[index+1].T.dot(delta[-1])
            delta.append(delta_pullback[:-1,:]*self.sgm(self._layerInput[index], True))


    for index in range(self.layerCount):
        delta_index = self.layerCount - 1 - index

        if index == 0:
            layerOutput = np.vstack([input.T, np.ones([1,lnCases])])
        else:
            layerOutput = np.vstack([self._layerOutput[index - 1],np.ones([1,self._layerOutput[index - 1].shape[1]])])

        weightDelta = np.sum(
                            layerOutput[None,:,:].transpose(2,0,1)*delta[delta_index][None,:,:].transpose(2,1,0)
                            , axis = 0)

        self.weights[index] -= trainingRate*weightDelta

    return error



if __name__ == "__main__":
    bpn = BackPropagationNetwork((4,10,1))
    print(bpn.shape)
    print(bpn.weights)
    from sklearn import datasets
    iris = datasets.load_iris()
    X = iris.data[:, :4]  #
    y = iris.target
    y.shape = (150,1)

lvInput = X
lvTarget = y

lnMax = 1000
lnErr = 1e-5

for i in range(100000):
    err = bpn.TrainEpoch(lvInput, lvTarget)
    if i % 2500== 0:
        print("Iteration {0} t Error: {1:0.6f}".format(i,err))
    if err <= lnErr:
        print("Minimim error reached at iteration {0}".format(i))
        break


lvOutput = bpn.Run(lvInput)

print("input: {0} n Output :{1}".format(lvInput, lvOutput))