- Se elimino implementación obsoleta de Neuron (preparando vectorización)

- Se Implemento vectorización en capas y sistema de optimizadores con Momentum.
- Se actualizo tests unitarios y script de ejemplo para nueva arquitectura.

Author: elJulioDev

main.py

@@ -1,41 +1,24 @@
+# Nuevo main.py de ejemplo
 import numpy as np
 from src.neural_network import NeuralNetwork
-from src.activations import Sigmoid, LeakyReLU 
+from src.activations import LeakyReLU, Sigmoid
 from src.losses import BinaryCrossEntropy
+from src.optimizers import SGD
 
 if __name__ == "__main__":
-    # --- Datos de entrenamiento (Compuerta XOR) ---
-    # Entradas: [0,0], [0,1], [1,0], [1,1]
-    X = np.array([
-        [0, 0],
-        [0, 1],
-        [1, 0],
-        [1, 1]
-    ])
-    
-    # Salidas esperadas: 0, 1, 1, 0
-    y = np.array([
-        [0],
-        [1],
-        [1],
-        [0]
-    ])
-
-    print("--- Inicializando Red Neuronal ---")
-    nn = NeuralNetwork(loss_function=BinaryCrossEntropy())
+    X = np.array([[0,0], [0,1], [1,0], [1,1]])
+    y = np.array([[0], [1], [1], [0]])
 
-    # Estructura: 2 entradas -> Capa Oculta (4 neuronas) -> Salida (1 neurona)
+    # Definimos optimizador con Momentum (Acelera el entrenamiento)
+    optimizer = SGD(learning_rate=0.1, momentum=0.9)
 
-    # CAMBIO: Usamos LeakyReLU en la oculta para mayor seguridad
-    nn.add_layer(num_neurons=4, input_size=2, activation=LeakyReLU()) 
+    nn = NeuralNetwork(loss_function=BinaryCrossEntropy(), optimizer=optimizer)
+    
+    # Arquitectura
+    nn.add_layer(num_neurons=4, input_size=2, activation=LeakyReLU())
     nn.add_layer(num_neurons=1, activation=Sigmoid())
 
-    print("--- Iniciando Entrenamiento ---")
-    # Entrenamos con una tasa de aprendizaje baja para ver la convergencia
-    nn.train(X, y, epochs=10000, learning_rate=0.1)
-
-    print("\n--- Resultados Finales ---")
-    predictions = nn.predict(X)
+    # Entrenar (Batch size 4 es todo el dataset en este caso pequeño)
+    nn.train(X, y, epochs=100000, batch_size=4)
 
-    for i in range(len(X)):
-        print(f"Entrada: {X[i]} | Predicción: {predictions[i][0]:.4f} | Esperado: {y[i][0]}")
+    print(nn.predict(X))

requirements.txt

@@ -1,3 +1,3 @@
-numpy
-python-dotenv
-setuptools
+numpy>=2.4.0
+python-dotenv>=1.2.1
+matplotlib>=3.10.8

src/activations.py

@@ -20,11 +20,25 @@ def derivative(self, x):
 class LeakyReLU(Activation):
     def __init__(self, alpha=0.01):
         self.alpha = alpha
-
     def forward(self, x):
-        # Si x > 0 devuelve x, si no, devuelve x * 0.01
         return np.where(x > 0, x, x * self.alpha)
+    def derivative(self, x):
+        return np.where(x > 0, 1, self.alpha)
+
+class Softmax(Activation):
+    def forward(self, x):
+        # Estabilidad numérica: restar el max
+        exp_vals = np.exp(x - np.max(x, axis=1, keepdims=True))
+        return exp_vals / np.sum(exp_vals, axis=1, keepdims=True)
 
     def derivative(self, x):
-        # Si x > 0 la derivada es 1, si no, es 0.01
-        return np.where(x > 0, 1, self.alpha)
+        # Truco: Usualmente Softmax se usa con CategoricalCrossEntropy
+        # y la derivada simplificada de ambas juntas es (pred - y).
+        # Por lo tanto, aquí retornamos 1 para que la Loss maneje el gradiente.
+        return 1
+
+class Linear(Activation):
+    def forward(self, x):
+        return x
+    def derivative(self, x):
+        return np.ones_like(x)

src/layer.py

@@ -1,18 +1,60 @@
 import numpy as np
-from .neuron import Neuron
-from .activations import Sigmoid
 
 class Layer:
-    def __init__(self, num_neurons, inputs_size, activation=Sigmoid()):
+    def __init__(self, n_neurons, input_size, activation):
+        self.n_neurons = n_neurons
+        self.input_size = input_size
         self.activation = activation
-        # Pasamos 'activation' a la Neurona
-        self.neurons = [Neuron(inputs_size, activation) for _ in range(num_neurons)]
+        
+        # Inicialización de He (Estándar profesional)
+        # Weights: matriz (input_size x n_neurons)
+        self.weights = np.random.randn(input_size, n_neurons) * np.sqrt(2 / input_size)
+        self.biases = np.zeros((1, n_neurons))
+        
+        # Cache para backward pass
+        self.inputs = None
+        self.z = None
+        self.dweights = None
+        self.dbiases = None
 
-    def forward(self, inputs):
-        return np.array([neuron.forward(inputs) for neuron in self.neurons])
-    
-    def backward(self, d_outputs, learning_rate):
-        d_inputs = np.zeros_like(self.neurons[0].inputs, dtype=float)
-        for i, neuron in enumerate(self.neurons):
-            d_inputs += neuron.backward(d_outputs[i], learning_rate)
-        return d_inputs
+    def forward(self, inputs, training=True):
+        self.inputs = inputs
+        # Operación matricial: (Batch x Input) dot (Input x Neurons) = (Batch x Neurons)
+        self.z = np.dot(inputs, self.weights) + self.biases
+        return self.activation.forward(self.z)
+
+    def backward(self, d_output):
+        # d_output viene de la capa siguiente: dL/dA
+        # Multiplicamos por la derivada de la activación: dA/dZ
+        d_activation = d_output * self.activation.derivative(self.z)
+        
+        # Calculamos gradientes
+        m = self.inputs.shape[0] # Tamaño del batch
+        
+        # dW = X.T dot dZ
+        self.dweights = np.dot(self.inputs.T, d_activation)
+        
+        # db = sum(dZ)
+        self.dbiases = np.sum(d_activation, axis=0, keepdims=True)
+        
+        # dX (Error para la capa anterior) = dZ dot W.T
+        d_input = np.dot(d_activation, self.weights.T)
+        
+        return d_input
+
+class Dropout(Layer):
+    def __init__(self, rate):
+        self.rate = rate
+        self.mask = None
+        self.n_neurons = 0 # No tiene neuronas propias
+
+    def forward(self, inputs, training=True):
+        if training:
+            # Máscara binomial (escala por 1/(1-rate) para mantener magnitud)
+            self.mask = np.random.binomial(1, 1 - self.rate, size=inputs.shape) / (1 - self.rate)
+            return inputs * self.mask
+        return inputs
+
+    def backward(self, d_output):
+        # El gradiente solo pasa por donde la máscara era 1
+        return d_output * self.mask

src/losses.py

@@ -7,16 +7,23 @@ def derivative(self, output, y): pass
 class MSE(Loss):
     def calculate(self, output, y):
         return np.mean((y - output) ** 2)
-    
     def derivative(self, output, y):
-        return 2 * (output - y) / y.size # Normalizado por tamaño
+        return 2 * (output - y) / y.shape[0]
 
 class BinaryCrossEntropy(Loss):
     def calculate(self, output, y):
-        # Clip para evitar log(0)
         output = np.clip(output, 1e-15, 1 - 1e-15)
         return -np.mean(y * np.log(output) + (1 - y) * np.log(1 - output))
-
     def derivative(self, output, y):
         output = np.clip(output, 1e-15, 1 - 1e-15)
-        return (output - y) / (output * (1 - output)) / y.size
+        return (output - y) / (output * (1 - output)) / y.shape[0]
+
+class CategoricalCrossEntropy(Loss):
+    def calculate(self, output, y):
+        # y debe ser one-hot encoded
+        output = np.clip(output, 1e-15, 1 - 1e-15)
+        return -np.sum(y * np.log(output)) / y.shape[0]
+    
+    def derivative(self, output, y):
+        # Asumiendo combinación con Softmax
+        return (output - y) / y.shape[0]

src/neural_network.py

@@ -1,14 +1,16 @@
 import numpy as np
 import pickle
-from .layer import Layer
-from .activations import Sigmoid  
+from .layer import Layer, Dropout
+from .activations import Sigmoid
 from .losses import MSE
+from .optimizers import SGD
 
 class NeuralNetwork:
-    def __init__(self, loss_function=MSE()):
+    def __init__(self, loss_function=MSE(), optimizer=None):
         self.layers = []
-        self.loss_list = []
         self.loss_function = loss_function
+        # Por defecto usamos SGD si no se pasa uno
+        self.optimizer = optimizer if optimizer else SGD(learning_rate=0.01)
 
     def add_layer(self, num_neurons, input_size=None, activation=None):
         if activation is None:
@@ -19,59 +21,65 @@ def add_layer(self, num_neurons, input_size=None, activation=None):
                 raise ValueError("Debes definir input_size para la primera capa.")
             self.layers.append(Layer(num_neurons, input_size, activation))
         else:
-            previous_output_size = len(self.layers[-1].neurons)
-            self.layers.append(Layer(num_neurons, previous_output_size, activation))
-          
-    def forward(self, inputs):
+            # Busca la última capa que tenga neuronas (ignora Dropout para contar outputs)
+            last_layer_size = 0
+            for layer in reversed(self.layers):
+                if hasattr(layer, 'n_neurons') and layer.n_neurons > 0:
+                    last_layer_size = layer.n_neurons
+                    break
+            self.layers.append(Layer(num_neurons, last_layer_size, activation))
+    
+    def add_dropout(self, rate):
+        self.layers.append(Dropout(rate))
+
+    def forward(self, inputs, training=True):
         for layer in self.layers:
-            inputs = layer.forward(inputs)
+            inputs = layer.forward(inputs, training=training)
         return inputs
 
-    def backward(self, loss_gradient, learning_rate):
+    def backward(self, loss_gradient):
+        # Propagar el error hacia atrás
         for layer in reversed(self.layers):
-            loss_gradient = layer.backward(loss_gradient, learning_rate)
+            loss_gradient = layer.backward(loss_gradient)
 
-    def train(self, x, y, epochs=1000, learning_rate=0.1):
-        indices = np.arange(len(x))
-        
+    def train(self, x, y, epochs=1000, batch_size=32):
         for epoch in range(epochs):
-            epoch_loss = 0
+            # 1. Shuffle (Barajado)
+            permutation = np.random.permutation(x.shape[0])
+            x_shuffled = x[permutation]
+            y_shuffled = y[permutation]
 
-            # Barajado de datos (Shuffle)
-            np.random.shuffle(indices)
+            epoch_loss = 0
 
-            for i in indices:
-                # 1. Forward
-                output = self.forward(x[i])
+            # 2. Mini-Batch Gradient Descent
+            for i in range(0, len(x), batch_size):
+                # Crear batch
+                x_batch = x_shuffled[i:i+batch_size]
+                y_batch = y_shuffled[i:i+batch_size]
 
-                # 2. Calcular Loss
-                epoch_loss += self.loss_function.calculate(output, y[i])
+                # Forward
+                output = self.forward(x_batch, training=True)
 
-                # 3. Calcular gradiente
-                loss_gradient = self.loss_function.derivative(output, y[i])
+                # Calcular Loss y Gradiente de Loss
+                loss = self.loss_function.calculate(output, y_batch)
+                epoch_loss += loss
+                grad = self.loss_function.derivative(output, y_batch)
 
-                # 4. Backward
-                self.backward(loss_gradient, learning_rate)
-            
-            # --- ESTAS LÍNEAS FALTABAN ---
-            # Calcular promedio del error en este epoch
-            epoch_loss /= len(x)
-            self.loss_list.append(epoch_loss)
+                # Backward (Calcula gradientes dW, db)
+                self.backward(grad)
+                
+                # Optimizer Step (Actualiza pesos)
+                self.optimizer.update(self.layers)
 
-            # Imprimir progreso cada 100 épocas
             if epoch % 100 == 0:
-                print(f"Epoch: {epoch}, Loss: {epoch_loss:.6f}")
+                print(f"Epoch: {epoch}, Loss promedio: {epoch_loss / (len(x)/batch_size):.6f}")
 
     def predict(self, x):
-        predictions = []
-        for i in range(len(x)):
-            predictions.append(self.forward(x[i]))
-        return np.array(predictions)
+        return self.forward(x, training=False)
 
     def save_model(self, filename):
         with open(filename, 'wb') as file:
             pickle.dump(self, file)
-        print(f"Modelo guardado en {filename}")
 
     @staticmethod
     def load_model(filename):