feat: use DeepNNLayer in Autoencoder

autoencoder.py

@@ -3,27 +3,28 @@ from utils import (dynamic_loss_plot_init,
                    dynamic_loss_plot_update,
                    dynamic_loss_plot_finish)
 from tqdm import tqdm
-from layers import NNLayer
+from layers import DeepNNLayer
 
 LOADER = ['⡿', '⣟', '⣯', '⣷', '⣾', '⣽', '⣻', '⢿']
 
 
 class Autoencoder:
     def __init__(self,
-                 in_len: int,
-                 bottleneck: int,
+                 encoder_layers: list[int],
+                 decoder_layers: list[int],
                  lr: float,
                  activation_func):
-        self.encoder = NNLayer(in_len, bottleneck, lr, activation_func)
-        self.decoder = NNLayer(bottleneck, in_len, lr, activation_func)
+        self.encoder = DeepNNLayer(encoder_layers, lr, activation_func)
+        self.decoder = DeepNNLayer(decoder_layers, lr, activation_func)
 
-    def train(self, v: np.ndarray) -> float:
-        encoded = self.encoder.forward(v)
-        reconstructed = self.decoder.forward(encoded)
-        error = self.decoder.backprop(reconstructed - v)
-        self.encoder.backprop(error)
-        error = v - reconstructed
-        return np.sum(np.abs(error))
+    def train(self, v: np.ndarray):
+        out = self.decoder.forward(
+            self.encoder.forward(v)
+        )
+        self.encoder.backprop(
+            self.decoder.backprop(out - v)
+        )
+        return np.sum(np.abs(out - v)) / len(v)
 
     def train_dataset(self,
                       data_set: list[np.ndarray],
@@ -60,9 +61,9 @@ class Autoencoder:
                 if epoch > max_epoch:
                     break
                 epoch += 1
+        print("Training complete !")
         if display_loss is True:
             dynamic_loss_plot_finish(ax, line)
-            print("#Training complete !")
         return losses
 
     def encode(self, v: np.ndarray) -> np.ndarray:

mnist_test.py

@@ -26,8 +26,17 @@ def mnist_test(
     x_train = np.divide(x_train, 255)
     x_test = np.divide(x_train, 255)
     in_len = x_train[0].shape[0] * x_train[0].shape[0]
-    autoencoder = Autoencoder(in_len, bottleneck, 0.001, relu)
-    autoencoder.train_dataset(x_train, max_epoch, patience, display_loss=True)
+    autoencoder = Autoencoder(
+        [in_len, bottleneck],
+        [bottleneck, in_len],
+        0.1,
+        relu
+    )
+    autoencoder.train_dataset(
+        x_train,
+        max_epoch,
+        patience,
+        display_loss=True)
     example: np.ndarray = x_test[np.random.randint(0, len(x_test))]
     code = autoencoder.encode(example.flatten())
     output = autoencoder.decode(code)