Raw emg vae

.gitignore

@@ -0,0 +1,4 @@
+/mps_test.py
+/emg_data_folder/
+/logs
+/venv

examples/run_mnist_io_variational_autoencoder.py

@@ -0,0 +1,100 @@
+"""Example of training a 2D convolutional neural network to autoencode 
+8x8 MNIST images"""
+
+import os, sys
+
+if os.path.basename(os.getcwd()) == "examples":
+    os.chdir("..")
+sys.path.append(os.path.abspath(""))
+
+from training import TrainingModule
+
+if __name__ == "__main__":
+    # The entirety of the run is defined by config, which will be unpacked
+    # at run time. The training module will look in the loader_modules
+    # and update_modules __init__.py for the named modules and then pass
+    training_module_config = {
+        "log_name": "mnist_vae",
+        "update_module_config": {
+            "update_module_name": "IOVariationalAutoencoder",
+            "update_module_kwargs": {
+                "optimizer": "multimodel",
+                "optimizer_kwargs": {
+                    0: {
+                        "optimizer": "AdamW",
+                        "optimizer_kwargs": {"lr": 0.01},
+                    },
+                    1: {
+                        "optimizer": "AdamW",
+                        "optimizer_kwargs": {"lr": 0.01},
+                    },
+                },
+                "beta_step": 1e-2,
+                "max_beta": 1,
+                "n_steps_per_switch": 5,
+                "network_training_steps": [20, 10],
+                "n_samples_in_aux": 32,
+            },
+            "maximize_val_target": False,
+            "network_config": {
+                "network_name": "multimodel",
+                "network_kwargs": {
+
+                    0: {
+                        "network_name": "vae.MLPVariationalAutoencoder",
+                        "network_kwargs": {
+                            "latent_dim": 5,
+                            "out_chans_per_layer": [256, 128, 64],
+                            "fix_recon_var": False,
+                        },
+                    },
+
+                    1: {
+                        "network_name": "blocks.MLPBlock",
+                        "network_kwargs": {
+                            "input_shape": [5],
+                            "output_shape": [1],
+                            "out_chans_per_layer": [8, 8],
+                            "output_activation": "Sigmoid",
+                        },
+                    },
+                },
+            },
+        },
+        "loader_module_config": {
+            "loader_module_name": "MNIST28",
+            "loader_module_kwargs": {
+                "batch_size": 32,
+                "auto": True,
+                "flatten_input": True,
+            },
+        },
+
+        "latents_visualization": True,
+
+        "trainer_kwargs": {
+            "accelerator": "gpu",
+            "devices": 1,
+            "max_epochs": 100,
+            "log_every_n_steps": 1,
+        },
+
+
+
+    }
+
+    # Once the config is defined it can be passed to an instance of the
+    # training module
+    training_module = TrainingModule(training_module_config)
+
+    # Train the model and pass the results to tensorboard
+    training_module.train()
+
+
+
+    """"trainer_kwargs": {
+        "accelerator": "cpu",
+        "devices": 1,
+        "max_epochs": 200,
+        "log_every_n_steps": 1,
+    },"""

examples/run_mnist_sparse_autoencoder.py

@@ -26,17 +26,24 @@
             "network_config": {
                 "network_name": "sparse.Conv2dSparseAutoencoder",
                 "network_kwargs": {
-                    "input_shape": [1, 8, 8],
-                    "output_shape": [1, 8, 8],
-                    "sparse_dim": 3,
-                    "out_chans_per_layer": [32, 64],
+                    "input_shape": [1, 28, 28],
+                    "output_shape": [1, 28, 28],
+                    "sparse_dim": 2,
+                    "out_chans_per_layer": [4, 8],
                 },
             },
         },
         "loader_module_config": {
-            "loader_module_name": "MNIST",
+            "loader_module_name": "MNIST28",
             "loader_module_kwargs": {"batch_size": 64, "auto": True},
         },
+        "trainer_kwargs": {
+            "accelerator": "gpu",
+            "devices": 1,
+            "max_epochs": 10,
+            "log_every_n_steps": 10,
+        },
+        "latents_visualization": True,
     }
 
     # Once the config is defined it can be passed to an instance of the

examples/run_mnist_variational_autoencoder_CNN.py

@@ -0,0 +1,70 @@
+"""Example of training a 2D convolutional neural network to autoencode
+8x8 MNIST images"""
+
+import os, sys
+
+if os.path.basename(os.getcwd()) == "examples":
+    os.chdir("..")
+sys.path.append(os.path.abspath(""))
+
+from training import TrainingModule
+
+if __name__ == "__main__":
+    # The entirety of the run is defined by config, which will be unpacked
+    # at run time. The training module will look in the loader_modules
+    # and update_modules __init__.py for the named modules and then pass
+    training_module_config = {
+        "log_name": "mnist_vae",
+        "update_module_config": {
+            "update_module_name": "VariationalAutoencoder",
+            "update_module_kwargs": {
+                "optimizer": "AdamW",
+                "optimizer_kwargs": {"lr": 0.01},
+                "beta_step": 1e-2,
+                "max_beta": 1.0,
+            },
+            "maximize_val_target": False,
+            "network_config": {
+                "network_name": "vae.Conv2dVariationalAutoencoder",
+                "network_kwargs": {
+                    "latent_dim": 4,
+                    "kernel_size_per_layer": 2,
+                    "stride_per_layer": 2,
+                    "out_chans_per_layer": [10, 20, 30],
+                    "fix_recon_var": False,
+                },
+            },
+        },
+        "loader_module_config": {
+            "loader_module_name": "MNIST28",
+            "loader_module_kwargs": {
+                "batch_size": 32,
+                "auto": True,
+                "flatten_input": False,
+            },
+        },
+        "trainer_kwargs": {
+            "accelerator": "gpu",
+            "devices": 1,
+            "max_epochs": 10,
+            "log_every_n_steps": 10,
+        },
+
+        "latents_visualization": True,
+    }
+
+    # Once the config is defined it can be passed to an instance of the
+    # training module
+    training_module = TrainingModule(training_module_config)
+
+    # Train the model and pass the results to tensorboard
+    training_module.train()
+
+
+
+    '''"trainer_kwargs": {
+        "accelerator": "cpu",
+        "devices": 1,
+        "max_epochs": 10,
+        "log_every_n_steps": 1,
+    },'''

examples/run_mnist_variational_autoencoder.py → examples/run_mnist_variational_autoencoder_MPL.py

@@ -1,4 +1,4 @@
-"""Example of training a 2D convolutional neural network to autoencode 
+"""Example of training a 2D convolutional neural network to autoencode
 8x8 MNIST images"""
 
 import os, sys
@@ -14,7 +14,7 @@
     # at run time. The training module will look in the loader_modules
     # and update_modules __init__.py for the named modules and then pass
     training_module_config = {
-        "log_name": "mnist_vae",
+        "log_name": "mnist_vae_MLP",
         "update_module_config": {
             "update_module_name": "VariationalAutoencoder",
             "update_module_kwargs": {
@@ -25,10 +25,10 @@
             },
             "maximize_val_target": False,
             "network_config": {
-                "network_name": "vae.Conv2dVariationalAutoencoder",
+                "network_name": "vae.MLPVariationalAutoencoder",
                 "network_kwargs": {
                     "latent_dim": 3,
-                    "out_chans_per_layer": [16, 32],
+                    "out_chans_per_layer": [256, 128],
                     "fix_recon_var": False,
                 },
             },
@@ -38,9 +38,17 @@
             "loader_module_kwargs": {
                 "batch_size": 32,
                 "auto": True,
-                "flatten_input": False,
+                "flatten_input": True,
             },
         },
+        "trainer_kwargs": {
+            "accelerator": "gpu",
+            "devices": 1,
+            "max_epochs": 20,
+            "log_every_n_steps": 1,
+        },
+
+        "latents_visualization": True,
     }
 
     # Once the config is defined it can be passed to an instance of the
@@ -50,9 +58,11 @@
     # Train the model and pass the results to tensorboard
     training_module.train()
 
+
+
     '''"trainer_kwargs": {
         "accelerator": "cpu",
         "devices": 1,
-        "max_epochs": 200,
+        "max_epochs": 10,
         "log_every_n_steps": 1,
     },'''

examples/run_raw_emg_classifier_vae_CNN.py

@@ -0,0 +1,68 @@
+"""Example of training a 1D convolutional neural network to learn a classifier
+ on MU labelled EMG"""
+
+import os, sys
+from ray import tune
+
+if os.path.basename(os.getcwd()) == "examples":
+    os.chdir("..")
+sys.path.append(os.path.abspath(""))
+
+from training import TrainingModule
+
+if __name__ == "__main__":
+    # The entirety of the run is defined by config, which will be unpacked
+    # at run time. The training module will look in the loader_modules
+    # and update_modules __init__.py for the named modules and then pass
+    training_module_config = {
+        "log_name": "raw_emg_classifier_CNN",
+        "update_module_config": {
+            "update_module_name": "VariationalAutoencoder",
+            "update_module_kwargs": {
+                "optimizer": "AdamW",
+                "optimizer_kwargs": {"lr": 0.01},
+                "beta_step": 1.0e-2,
+                "max_beta": 1.0,
+            },
+            "maximize_val_target": True,
+            "network_config": {
+                "network_name": "vae.Conv2dVariationalAutoencoder",
+                "network_kwargs": {
+                    "latent_dim": 2,
+                    "kernel_size_per_layer": [(15, 1), (30, 1), (15, 1)],  # (time, channels) for each layer
+                    "stride_per_layer": [(1, 1), (3, 1), (5, 1)],  # (time, channels)
+                    "out_chans_per_layer": [10, 10, 20],
+                    "fix_recon_var": False,
+                },
+            },
+        },
+        "loader_module_config": {
+            "loader_module_name": "RawEMGLabelled",
+            "loader_module_kwargs": {
+                "file_path": "emg_data_folder/gesture_set_1",
+                "test_fraction": 0.1, # of whole dataset
+                "val_fraction": 0.03, # of test set
+                "group_size": 1,
+                "batch_size": 32,
+                "one_hot_labels": False,
+                "shuffle_data": False,
+                "flatten_input": False,
+                "rectify_emg": True,
+            },
+        },
+        "trainer_kwargs": {
+            "accelerator": "gpu",
+            "devices": 1,
+            "max_epochs": 30,
+            "log_every_n_steps": 10,
+        },
+
+        "latents_visualization": True,
+    }
+
+    # Once the config is defined it can be passed to an instance of the
+    # training module
+    training_module = TrainingModule(training_module_config)
+
+    # Train the model and pass the results to tensorboard
+    training_module.train()