import numpy as np
import nnwplot
import matplotlib.pyplot as plt


def error_rate(Y, T):
    if Y.ndim == 1 or Y.shape[0] == 1:
        errors = Y - T
        return errors.sum() / Y.size
    else:  # für mehrere Ausgaben in one-hot Kodierung:
        errors = Y.argmax(0) != T.argmax(0)
        return errors.sum() / Y.shape[1]


class SLN:
    def __init__(self, dIn, cOut):
        self.dIn = dIn
        self.cOut = cOut
        np.random.seed(42)
        self._b = np.zeros((cOut, 1))
        self._W = np.random.randn(dIn, cOut) / np.sqrt(dIn + 1)

    def neuron(self, X):
        N = X.shape[1]
        net = np.zeros(N)

        for n in range(0, N):
            value = 0
            for i in range(self.dIn):
                value += X[i, n] * self._W[i][0]
            net[n] += value + self._b[0][0]
        return net

    def delta_train(self, X, T, eta, maxIter, maxErrorRate):
        N = X.shape[1]  # Anzahl Trainingsdaten
        plt.ion()  # interactive mode on
        for it in range(maxIter):
            Y = self.neuron(X)  # nur ein Aufruf
            err = error_rate(Y, T)
            if (it % 10) == 0:
                print('#{} err:{}\n{}\n{}'.format(it, err, self._W, self._b))
                nnwplot.plotTwoFeatures(X, T, self.neuron)
                plt.pause(0.05)  # warte auf GUI event loop (je nach python Version notwendig oder nicht)
            if err <= maxErrorRate:
                break
            # update _W
            for n in range(N):
                for j in range(self.dIn):
                    weighted_error = err * X[j, n]
                    to_learn = weighted_error * eta
                    #print("{:.2f} = {} * {} * {}".format(to_learn, err, X[j, n], eta))
                    self._W[j, 0] += to_learn
                    self._b[0][0] -= to_learn
            # update _b
            ...
        print('#{} err:{}\n{}\n{}'.format(it, err, self._W, self._b))
        nnwplot.plotTwoFeatures(X, T, self.neuron)
        plt.pause(0.05)  # warte auf GUI event loop (je nach python Version notwendig oder nicht)