From branch Autoencoders

src/librep/estimators/ae/torch/models/topological_ae/model_submodules.py

@@ -314,24 +314,176 @@ def forward(self, x):
         x_reconst = self.decode(latent)
         reconst_error = self.reconst_error(x, x_reconst)
         return reconst_error, {'reconstruction_error': reconst_error}
-
+        
 
 class ConvTAE_def(AutoencoderModel):
     """Convolutional Topological Autoencoder - definitive version"""
     def __init__(
         self,
-        input_dims=(1, 180),
+        input_dims=(1, 180), # (6, 30) tambien funciona con input_dims[0] 
+        latent_dim=10,
+        num_CL=3, # 2 a 5
+        size_CL=12, # 4 a 24
+        num_HL=3, # 2 a 5
+        size_HL=50,
+        down_HL=0,
+        kernel_size=5,
+        groups=1
+    ):
+        """Convolutional Autoencoder."""
+        # print('ConvTAE, Input:', input_dims,'Latent dim:', latent_dim, 'CL,HL', num_CL, size_CL, num_HL, size_HL)
+        super().__init__()
+        # Size of the connection between conv-hidden / hidden-conv
+        connection_size = size_CL*(input_dims[1]-num_CL*(kernel_size-1))
+        if num_CL == 0:
+            connection_size = input_dims[1]
+        # Defining the list of layers to use
+        encoder_list_layers = []
+        decoder_list_layers = []
+        # --------------------------------------------------------------
+        # -------------------- BUILDING THE ENCODER --------------------
+        # --------------------------------------------------------------
+        # CONVOLUTIONAL LAYERS -----------------------------------------
+        # --------------------------------------------------------------
+        # Check if num_CL == 0
+        if num_CL != 0:
+            # All convolutional layers (only sizes)
+            conv_layers = [(size_CL, size_CL) for i in range(num_CL)]
+            # Editing first convolutional layer
+            conv_layers[0] = (input_dims[0], size_CL)
+            # Updating encoder layers
+            for pair in conv_layers:
+                layer = nn.Conv1d(
+                    in_channels=pair[0],
+                    out_channels=pair[1],
+                    kernel_size=kernel_size,
+                    stride=1,
+                    padding=0,
+                    groups=groups
+                )
+                encoder_list_layers.append(layer)
+                encoder_list_layers.append(nn.ReLU())
+            # Add the "View" view
+            encoder_list_layers.append(View((-1, connection_size)))
+        # --------------------------------------------------------------
+        # HIDDEN LAYERS ------------------------------------------------
+        # --------------------------------------------------------------
+        # Create dimensions with the sizes of the layers as intermediate valus between connection and latent
+        dimensions = np.linspace(connection_size, latent_dim, num_HL+1).round().astype(int)
+        for index, dim in enumerate(dimensions[:-1]):
+            layer = nn.Linear(dim, dimensions[index+1])
+            encoder_list_layers.append(layer)
+            encoder_list_layers.append(nn.ReLU())
+        # All hidden layers (only sizes)
+        # hidden_layers = [(size_HL-(i-1)*down_HL, size_HL-i*down_HL) for i in range(num_HL)]
+        # First layer (last of convolutional layers)
+        # hidden_layers[0] = (connection_size, size_HL)
+        # Last layer (low dimensionality)
+        # hidden_layers[-1] = (size_HL-(num_HL-2)*down_HL, latent_dim)
+        # Updating encoder layers
+        # for pair in hidden_layers:
+        #     layer = nn.Linear(pair[0], pair[1])
+        #     encoder_list_layers.append(layer)
+        #     encoder_list_layers.append(nn.ReLU())
+        # Delete the last ReLU()
+        encoder_list_layers.pop()
+        # Build the encoder
+        self.encoder = nn.Sequential(*encoder_list_layers)
+        # --------------------------------------------------------------
+        # -------------------- BUILDING THE DECODER --------------------
+        # --------------------------------------------------------------
+        # HIDDEN LAYERS ------------------------------------------------
+        # --------------------------------------------------------------
+        # All hidden layers (only sizes)
+        # hidden_layers = [(size_HL-(num_HL-i)*down_HL, size_HL-(num_HL-i+1)*down_HL) for i in range(num_HL)]
+        # First layer (low dimensionality)
+        # hidden_layers[0] = (latent_dim, size_HL-(num_HL-2)*down_HL)
+        # Last layer (first of convolutional layers)
+        # hidden_layers[-1] = (size_HL, connection_size)
+        # Updating decoder layers
+        # for pair in hidden_layers:
+        #     layer = nn.Linear(pair[0], pair[1])
+        #     decoder_list_layers.append(layer)
+        #     decoder_list_layers.append(nn.ReLU())
+        # Reversing dimensions
+        dimensions = dimensions[::-1]
+        for index, dim in enumerate(dimensions[:-1]):
+            layer = nn.Linear(dim, dimensions[index+1])
+            decoder_list_layers.append(layer)
+            decoder_list_layers.append(nn.ReLU())
+        # Adding the "View" view before the last ReLU()
+        if num_CL != 0:
+            last_relu = decoder_list_layers.pop()
+            decoder_list_layers.append(View((-1, size_CL, input_dims[1]-num_CL*(kernel_size-1))))
+            decoder_list_layers.append(last_relu)
+        # --------------------------------------------------------------
+        # CONVOLUTIONAL LAYERS -----------------------------------------
+        # --------------------------------------------------------------
+        # All convolutional layers (only sizes)
+        # Check if num_CL == 0
+        if num_CL != 0:
+            conv_layers = [(size_CL, size_CL) for i in range(num_CL)]
+            # Editing last convolutional layer
+            conv_layers[-1] = (size_CL, input_dims[0])
+            # Updating decoder layers
+            for pair in conv_layers:
+                layer = nn.ConvTranspose1d(
+                    in_channels=pair[0],
+                    out_channels=pair[1],
+                    kernel_size=kernel_size,
+                    stride=1,
+                    padding=0
+                )
+                decoder_list_layers.append(layer)
+                decoder_list_layers.append(nn.ReLU())
+        # Build the decoder
+        self.decoder = nn.Sequential(*decoder_list_layers)
+        # print(self.encoder, '\n')
+        # print(self.decoder)
+        self.reconst_error = nn.MSELoss()
+
+    def encode(self, x):
+        """Compute latent representation using convolutional autoencoder."""
+        return self.encoder(x)
+
+    def decode(self, z):
+        """Compute reconstruction using convolutional autoencoder."""
+        return self.decoder(z)
+
+    def forward(self, x):
+        """Apply autoencoder to batch of input images.
+        Args:
+            x: Batch of images with shape [bs x channels x n_row x n_col]
+        Returns:
+            tuple(reconstruction_error, dict(other errors))
+        """
+        latent = self.encode(x)
+        x_reconst = self.decode(latent)
+        # print('LATENT', latent.shape, 'XRECONST', x_reconst.shape)
+        reconst_error = self.reconst_error(x, x_reconst)
+        return reconst_error, {'reconstruction_error': reconst_error}
+
+
+class ConvTAE_def_2d(AutoencoderModel):
+    """Convolutional Topological Autoencoder - definitive version"""
+    def __init__(
+        self,
+        input_dims=(1, 6, 60), # (6, 30) tambien funciona con input_dims[0] 
         latent_dim=10,
         num_CL=3, # 2 a 5
         size_CL=12, # 4 a 24
         num_HL=3, # 2 a 5
-        size_HL=50
+        size_HL=50,
+        down_HL=0,
+        kernel_size=(6,2), # (6,n) (3,n) con stride 3
+        stride=1,
+        padding=0
     ):
         """Convolutional Autoencoder."""
-        print('ConvTAE, Input:', input_dims,'Latent dim:', latent_dim)
+        # print('ConvTAE, Input:', input_dims,'Latent dim:', latent_dim, 'CL,HL', num_CL, size_CL, num_HL, size_HL)
         super().__init__()
         # Size of the connection between conv-hidden / hidden-conv
-        connection_size = size_CL*(input_dims[1]-num_CL*4)
+        connection_size = size_CL*(input_dims[1]*input_dims[2]-num_CL*(kernel_size-1))
         if num_CL == 0:
             connection_size = input_dims[1]
         # Defining the list of layers to use
@@ -347,13 +499,13 @@ def __init__(
             # All convolutional layers (only sizes)
             conv_layers = [(size_CL, size_CL) for i in range(num_CL)]
             # Editing first convolutional layer
-            conv_layers[0] = (1, size_CL)
+            conv_layers[0] = (input_dims[0], size_CL)
             # Updating encoder layers
             for pair in conv_layers:
                 layer = nn.Conv1d(
                     in_channels=pair[0],
                     out_channels=pair[1],
-                    kernel_size=5,
+                    kernel_size=kernel_size,
                     stride=1,
                     padding=0
                 )
@@ -365,11 +517,11 @@ def __init__(
         # HIDDEN LAYERS ------------------------------------------------
         # --------------------------------------------------------------
         # All hidden layers (only sizes)
-        hidden_layers = [(size_HL, size_HL) for i in range(num_HL)]
+        hidden_layers = [(size_HL-(i-1)*down_HL, size_HL-i*down_HL) for i in range(num_HL)]
         # First layer (last of convolutional layers)
         hidden_layers[0] = (connection_size, size_HL)
         # Last layer (low dimensionality)
-        hidden_layers[-1] = (size_HL, latent_dim)
+        hidden_layers[-1] = (size_HL-(num_HL-2)*down_HL, latent_dim)
         # Updating encoder layers
         for pair in hidden_layers:
             layer = nn.Linear(pair[0], pair[1])
@@ -385,9 +537,9 @@ def __init__(
         # HIDDEN LAYERS ------------------------------------------------
         # --------------------------------------------------------------
         # All hidden layers (only sizes)
-        hidden_layers = [(size_HL, size_HL) for i in range(num_HL)]
+        hidden_layers = [(size_HL-(num_HL-i)*down_HL, size_HL-(num_HL-i+1)*down_HL) for i in range(num_HL)]
         # First layer (low dimensionality)
-        hidden_layers[0] = (latent_dim, size_HL)
+        hidden_layers[0] = (latent_dim, size_HL-(num_HL-2)*down_HL)
         # Last layer (first of convolutional layers)
         hidden_layers[-1] = (size_HL, connection_size)
         # Updating decoder layers
@@ -398,7 +550,7 @@ def __init__(
         # Adding the "View" view before the last ReLU()
         if num_CL != 0:
             last_relu = decoder_list_layers.pop()
-            decoder_list_layers.append(View((-1, size_CL, input_dims[1]-num_CL*4)))
+            decoder_list_layers.append(View((-1, size_CL, input_dims[1]-num_CL*(kernel_size-1))))
             decoder_list_layers.append(last_relu)
         # --------------------------------------------------------------
         # CONVOLUTIONAL LAYERS -----------------------------------------
@@ -408,21 +560,21 @@ def __init__(
         if num_CL != 0:
             conv_layers = [(size_CL, size_CL) for i in range(num_CL)]
             # Editing last convolutional layer
-            conv_layers[-1] = (size_CL, 1)
+            conv_layers[-1] = (size_CL, input_dims[0])
             # Updating decoder layers
             for pair in conv_layers:
                 layer = nn.ConvTranspose1d(
                     in_channels=pair[0],
                     out_channels=pair[1],
-                    kernel_size=5,
+                    kernel_size=kernel_size,
                     stride=1,
                     padding=0
                 )
                 decoder_list_layers.append(layer)
                 decoder_list_layers.append(nn.ReLU())
         # Build the decoder
         self.decoder = nn.Sequential(*decoder_list_layers)
-        # print(self.encoder)
+        # print(self.encoder, '\n')
         # print(self.decoder)
         self.reconst_error = nn.MSELoss()
 

src/librep/estimators/ae/torch/models/topological_ae/topological_ae.py

@@ -15,7 +15,6 @@ def __init__(self, lam=1., autoencoder_model='ConvolutionalAutoencoder',
             ae_kwargs: Kewords to pass to `ConvolutionalAutoencoder` class
             toposig_kwargs: Keywords to pass to `TopologicalSignature` class
         """
-        print('Topologically Regularized', autoencoder_model)
         super().__init__()
         self.lam = lam
         ae_kwargs = ae_kwargs if ae_kwargs else {}
@@ -59,8 +58,6 @@ def forward(self, x):
 
         # Use reconstruction loss of autoencoder
         ae_loss, ae_loss_comp = self.autoencoder(x)
-#         print('TEST'*20)
-#         print(self.topo_sig(x_distances, latent_distances))
         topo_error, topo_error_components = self.topo_sig(
             x_distances, latent_distances)
 

src/librep/estimators/ae/torch/models/topological_ae/topological_signature_distance.py

@@ -34,7 +34,6 @@ def __init__(self, sort_selected=False, use_cycles=False,
         ##self.signature_calculator = AlephPersistenHomologyCalculation(
         ##    compute_cycles=use_cycles, sort_selected=sort_selected)
         # else:
-        print('Using python to compute signatures')
         self.signature_calculator = PersistentHomologyCalculation()
 
     def _get_pairings(self, distances):

src/librep/estimators/convaelstm/convaelstm.py

@@ -0,0 +1,82 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ConvAELSTM_part_ConvAE(nn.Module):
+    def __init__(self, start_dim, n_channels, kernel_size=3, stride=2, padding=0, filter_size=64):
+        super().__init__()
+        self.start_dim = start_dim
+        self.model = nn.Sequential(
+            nn.Conv1d(in_channels=n_channels,out_channels=filter_size,kernel_size=kernel_size,stride=stride,padding=padding),
+            nn.MaxPool1d(kernel_size=kernel_size, stride=stride, padding=padding),
+            nn.ConvTranspose1d(in_channels=filter_size,out_channels=n_channels,kernel_size=kernel_size,stride=stride,padding=padding),
+            nn.ReLU())
+        print('MODEL', self.model)
+
+    def forward(self, x):
+        return self.model(x)
+
+
+class ConvAELSTM_part_LSTM(nn.Module):
+    def __init__(self, latent_dim, device, n_layers, input_size):
+        super(ConvAELSTM_part_LSTM, self).__init__()
+        self.device = device
+        self.n_layers = n_layers
+        self.lstm = nn.LSTM(
+            hidden_size = latent_dim,
+            input_size=input_size,
+            num_layers=n_layers,
+            batch_first=True
+            )
+        self.latent_dim=latent_dim
+
+    def forward(self, x):
+        # h_0 = torch.zeros(self.n_layers, x.shape[0], self.latent_dim).float().to(self.device)
+        # c_0 = torch.zeros(self.n_layers, x.shape[0], self.latent_dim).float().to(self.device)
+        h_n, _ = self.lstm(x)
+        return h_n[:,-1] # returning the last hidden state
+
+
+class ConvAELSTM_part_Softmax(nn.Module):
+    def __init__(self, latent_dim, n_classes):
+        super().__init__()
+        self.fully_connected = nn.Linear(latent_dim, n_classes)
+
+    def forward(self, x):
+        x = self.fully_connected(x)
+        x = F.log_softmax(x, dim=1)
+        return x
+
+
+class ConvAELSTM_full(nn.Module):
+    def __init__(self, latent_dim, device, n_layers, input_size, n_classes, sequence_length=60):
+        super().__init__()
+        self.sequence_length = sequence_length
+        self.input_size = input_size
+        self.conv = ConvAELSTM_part_ConvAE(start_dim=60, n_channels=input_size)
+        self.lstm = ConvAELSTM_part_LSTM(latent_dim=latent_dim, device=device, n_layers=n_layers, input_size=input_size)
+        self.softmax = ConvAELSTM_part_Softmax(latent_dim=latent_dim, n_classes=n_classes)
+
+    # Reshape the dataset into LSTM input 
+    def _reshapeToLSTM(self, tensor):
+        # tensor = torch.reshape(tensor, (tensor.shape[0], self.input_size, self.sequence_length)) # (n_samples, 6, 60)
+        return torch.permute(tensor, (0, 2, 1)) # (n_samples, seq_length, H_in)
+
+
+    def forward(self, x):
+        # print('x before conv', x.shape)
+        x = self.conv(x)
+        # print('x after conv', x.shape)
+        x = self.lstm(self._reshapeToLSTM(x))
+        x = self.softmax(x)
+        return x
+
+    def reduce_dim(self, x):
+        self.conv.eval()
+        self.lstm.eval()
+        print('x before conv', x.shape)
+        x = self.conv(x)
+        print('x after conv', x.shape)
+        x = self.lstm(self._reshapeToLSTM(x))
+        return x

src/librep/metrics/dimred_evaluator.py

@@ -101,12 +101,12 @@ def evaluate(
         if self.use_local_property:
             # res = np.mean([drm.Qlocal for drm in drms])
             res = drm.Qlocal
-            result["local property"] = res
+            result["local property"] = float(res)
 
         if self.use_global_property:
             # res = np.mean([drm.Qglobal for drm in drms])
             res = drm.Qglobal
-            result["global property"] = res
+            result["global property"] = float(res)
 
         return result
 

src/librep/transforms/__init__.py

@@ -1,4 +1,5 @@
 from .fft import *
+from .lstm import *
 from .resampler import *
 from .umap import *
 from .tsne import *