Clase NNClassifier v4

class NNClassifier(object):
    
    def __init__(self, sizes, learning_rate = 0.01, batch_size = 16, epochs = 10):
        """ Constructor de la red neuronal """
        self.num_layers = len(sizes)         # Número total de capas de la red
        self.sizes = sizes                   # Lista conteniendo el número de neuronas por capa
        self.learning_rate = learning_rate   # Tasa de aprendizaje
        self.batch_size = batch_size         # Tamaño del batch
        self.epochs = epochs                 # Número de epochs durante los que entrenar la red
        self.weights = [np.random.randn(x, y) for (x, y) in zip(sizes[1:], sizes[:-1])]
        self.biases = [np.random.randn(n, 1) for n in sizes[1:]]
    
    def __update_parameters(self, mini_batch, learning_rate):
        """ Actualiza los parámetros de la red (pesos y bias) aplicando descenso de gradiente 
        a cada mini-batch. Un mini-batch es una lista de tuplas (x, y) """
    pass
    
    def fit(self, X: pd.core.frame.DataFrame, y: pd.core.series.Series):
        """ Entrenamiento de la red neuronal"""
        x_train = [x.values.reshape(-1, 1) for (i, x) in X.iterrows()]
        y_train = [to_categorical(n, self.sizes[-1]) for n in y]
        training_data = [(x, y) for (x, y) in zip(x_train, y_train)]
        n = len(training_data)
        for epoch in range(self.epochs):
            mini_batches = [training_data[start:start + self.batch_size]
                            for start in range(0, n, self.batch_size)]
            for mini_batch in mini_batches:
                self.__update_parameters(mini_batch, self.learning_rate)
            print("Epoch {} complete".format(epoch))
    
    def getOutput(self, x: np.ndarray):
        """ Obtención de la predicción para una muestra """
        for b, w in zip(self.biases, self.weights):
            x = sigmoid(np.dot(w, x) + b)
        return x
    
    def predict(self, X: pd.core.frame.DataFrame):
        """ Obtención de la predicción para las muestras contenidas en un DataFrame """
        predictions = np.zeros(shape = len(X))
        X.reset_index(inplace = True, drop = True)
        for i, sample in X.iterrows():
            prediction = model.getOutput(sample.values.reshape(-1, 1))
            predictions[i] = np.argmax(prediction)
        return predictions

model = NNClassifier(
    sizes = [784, 16, 10], 
    learning_rate = 0.01,
    batch_size = 32,
    epochs = 10
)

model.fit(x_train, y_train)