############################################base.py###############################################
import numpy as np



class BpropComponent(object):

    __slots__ = [
        "inp",
        "out",
        "inp_dim",
        "out_dim",
        "grads",
        "W",
        "activateparams", # tuple!
        "ETA",
        "bias", # number!
    ]

    def __init__(self, inp_dim, out_dim, bias, **kwargs):

        self.activateparams = (1.7159, 2./3) # default params for tanh only
        self.ETA = .2

        self.inp_dim = inp_dim
        self.out_dim = out_dim
        self.bias = bias

        for key in kwargs.keys():
            if key in self.__slots__:
                object.__setattr__(self, key, kwargs[key])

    def forward(self, inp):
        print "ABSTRACT, override this"
        return

    def backward(self):
        print "ABSTRACT, override this"
        return

    # default activate function is tanh sigmoid
    def FI(self, data):
        return self.activateparams[0] * np.tanh(self.activateparams[1] * data)

    def dFI(self):
        return (self.activateparams[0]*self.activateparams[1]) * (1. - self.out) * (1. + self.out)


class BpropLayer(BpropComponent):

    __slots__ = BpropComponent.__slots__ + ["size", "nextlayer"]

    def __init__(self, inp_dim, out_dim, size, bias, **kwargs):
        self.nextlayer = None
        BpropComponent.__init__(self, inp_dim, out_dim, bias, **kwargs)
        self.size = size

    def bind(self, otherlayer):
        print "ABSTRACT, override this"
        return

###################################################fullcon.py###############################################################
import numpy as np
import logging

from base import BpropLayer



class TanhFullConLayer(BpropLayer):

    def __init__(self, size, inp_dim, bias, **kwargs):

        out_dim = 1 # for simple backpropagation neuron
        BpropLayer.__init__(self, inp_dim, out_dim, size, bias, **kwargs)

        self.W = np.random.normal(0, .01, (self.size, self.inp_dim))

    def bind(self, otherlayer):
        assert isinstance(otherlayer, BpropLayer)
        assert self.size == otherlayer.inp_dim
        self.nextlayer = otherlayer

    def forward(self, data):
        assert len(data) == self.inp_dim
        self.inp = data
        Sum = np.array(map(np.sum, self.W[:, :] * data[:])) + self.bias
        self.out = self.FI(Sum)
        return self.out

    def backward(self, err): # ошибка скорее всего тут, т.к. градиенты становятся какими-то совсем огромными
        if err is None:
            assert self.nextlayer is not None
            err = map(np.sum, self.nextlayer.W[:, :].T * self.nextlayer.grads[:])
            err = np.array(err)
        self.grads = err * self.dFI()
        logging.debug(str(self) + ' localgradients: ' + str(self.grads))
        dw = self.ETA * np.outer(self.grads, self.inp)
        logging.debug('sum of deltaW on ' + str(self) +': ' + str(np.sum(dw)))
        self.W += dw

    def __str__(self):
        if self.nextlayer:
            return 'hidden layer'
        else:
            return 'output layer'


class MLP(object):

    layers = []

    def __init__(self, topology, LayerClass):

        self.size = len(topology)

        for layerparams in topology:
            self.layers.append(LayerClass(*layerparams[:-1], **layerparams[-1]))

        for i in xrange(self.size-2, -1, -1):
            self.layers[i].bind(self.layers[i+1])

    def forward(self, inp):
        for layer in self.layers:
            out = layer.forward(inp)
            inp = out
        return out

    def backward(self, err):
        for i in xrange(self.size-1, -1, -1):
            self.layers[i].backward(err)
            err = None

    def train(self, dataset):
        for data, target in dataset:
            recog = self.forward(data)
            err = target - recog
            logging.debug('Mean squared error: ' + str(np.sum(err**2)))
            self.backward(err)

    def test(self, testset):
        for data, target in testset:
            recog = self.forward(data)
            logging.info('target:  ' + str(target))
            logging.info('net out: ' + str(recog))


if __name__=="__main__":

    from mnistmanager import data_set
    import sys

    data = data_set(100, "train", "vector", path=r"C:\Users\home\numpyprojects\ml")
    test = data_set(100, "test", "vector", path=r"C:\Users\home\numpyprojects\ml")

    topology = [
        (1000, 28*28, {'bias':0, 'ETA': .1}),
        (10, 1000, {'bias': 0, 'ETA': .1})
    ]

    level = logging.INFO
    filepath = "ml/logs/mlp.log"

    if '-d' in sys.argv:
        level = logging.DEBUG
        index = sys.argv.index('-d')
        if len(sys.argv) > index+1:
            filepath = sys.argv[index+1]

    logging.basicConfig(filename=filepath, level=level, filemode='w')

    net = MLP(topology, TanhFullConLayer)

    net.train(data)
    net.test(test)