diff --git a/Jenkinsfile b/Jenkinsfile
index 4c4fff6e5..a9bbc4ec6 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -27,7 +27,7 @@ pipeline {
             sh 'mamba env create -q -f environment.yml -p $CONDA_ENV'
             sh '''#!/bin/bash -ex
               source activate $CONDA_ENV
-              export KERAS_BACKEND=tensorflow
+              export KERAS_BACKEND=torch
               pip install .
               TEMPDIR=$(mktemp -d)
               export CAIMAN_DATA=$TEMPDIR/caiman_data
diff --git a/caiman/base/__init__.py b/caiman/base/__init__.py
index e69de29bb..b46d51dfe 100644
--- a/caiman/base/__init__.py
+++ b/caiman/base/__init__.py
@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+
+from caiman.base.timeseries import timeseries
\ No newline at end of file
diff --git a/caiman/base/movies.py b/caiman/base/movies.py
index f0a9a5796..6f6bc368b 100644
--- a/caiman/base/movies.py
+++ b/caiman/base/movies.py
@@ -37,12 +37,15 @@
 import caiman.utils.sbx_utils
 import caiman.utils.visualization
 
+from caiman.base.timeseries import timeseries
+from caiman.base.traces import trace 
+
 try:
     cv2.setNumThreads(0)
 except:
     pass
 
-class movie(caiman.base.timeseries.timeseries):
+class movie(timeseries):
     """
     Class representing a movie. This class subclasses timeseries,
     that in turn subclasses ndarray
@@ -895,7 +898,7 @@ def partition_FOV_KMeans(self,
         fovs = cv2.resize(np.uint8(fovs), (w1, h1), 1. / fx, 1. / fy, interpolation=cv2.INTER_NEAREST)
         return np.uint8(fovs), mcoef, distanceMatrix
 
-    def extract_traces_from_masks(self, masks: np.ndarray) -> caiman.base.traces.trace:
+    def extract_traces_from_masks(self, masks: np.ndarray) -> trace:
         """
         Args:
             masks: array, 3D with each 2D slice bein a mask (integer or fractional)
@@ -914,7 +917,7 @@ def extract_traces_from_masks(self, masks: np.ndarray) -> caiman.base.traces.tra
 
         pixelsA = np.sum(A, axis=1)
         A = A / pixelsA[:, None]       # obtain average over ROI
-        traces = caiman.base.traces.trace(np.dot(A, np.transpose(Y)).T, **self.__dict__)
+        traces = trace(np.dot(A, np.transpose(Y)).T, **self.__dict__)
         return traces
 
     def resize(self, fx=1, fy=1, fz=1, interpolation=cv2.INTER_AREA):
diff --git a/caiman/base/timeseries.py b/caiman/base/timeseries.py
index 334b2d786..92ad10250 100644
--- a/caiman/base/timeseries.py
+++ b/caiman/base/timeseries.py
@@ -33,7 +33,7 @@
     pass
 
 
-class timeseries(np.ndarray):
+class timeseries(np.ndarray): 
     """
     Class representing a time series.
     """
@@ -88,7 +88,7 @@ def __array_prepare__(self, out_arr, context=None):
         if context is not None:
             inputs = context[1]
             for inp in inputs:
-                if isinstance(inp, timeseries):
+                if isinstance(inp, timeseries): 
                     if frRef is None:
                         frRef = inp.fr
                     else:
diff --git a/caiman/base/traces.py b/caiman/base/traces.py
index 973f1fca1..ad3b90f4b 100644
--- a/caiman/base/traces.py
+++ b/caiman/base/traces.py
@@ -8,6 +8,7 @@
 plt.ion()
 
 import caiman.base.timeseries
+from caiman.base.timeseries import timeseries
 
 try:
     cv2.setNumThreads(0)
@@ -18,7 +19,7 @@
 # This holds the trace class, which is a specialised Caiman timeseries class.
 
 
-class trace(caiman.base.timeseries.timeseries):
+class trace(timeseries):
     """
     Class representing a trace.
 
diff --git a/caiman/components_evaluation.py b/caiman/components_evaluation.py
index 5bf9a47c0..c6486e90e 100644
--- a/caiman/components_evaluation.py
+++ b/caiman/components_evaluation.py
@@ -6,7 +6,7 @@
 import numpy as np
 import os
 import peakutils
-import tensorflow as tf
+import torch 
 import scipy
 from scipy.sparse import csc_matrix
 from scipy.stats import norm
@@ -273,42 +273,37 @@ def evaluate_components_CNN(A,
     if not isGPU and 'CAIMAN_ALLOW_GPU' not in os.environ:
         print("GPU run not requested, disabling use of GPUs")
         os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
-    try:
-        os.environ["KERAS_BACKEND"] = "tensorflow"
-        from tensorflow.keras.models import model_from_json
-        use_keras = True
-        logger.info('Using Keras')
-    except (ModuleNotFoundError):
-        use_keras = False
-        logger.info('Using Tensorflow')
+    # try: 
+    #    os.environ["KERAS_BACKEND"] = "torch"
+    #    from keras.models import model_load 
+    #    use_keras = True 
+    #    logging.info('Using Keras')
+    # except (ModuleNotFoundError):
+    # use_keras = False 
+    logging.info('Using Torch')
 
     if loaded_model is None:
-        if use_keras:
-            if os.path.isfile(os.path.join(caiman_datadir(), model_name + ".json")):
-                model_file = os.path.join(caiman_datadir(), model_name + ".json")
-                model_weights = os.path.join(caiman_datadir(), model_name + ".h5")
-            elif os.path.isfile(model_name + ".json"):
-                model_file = model_name + ".json"
-                model_weights = model_name + ".h5"
-            else:
-                raise FileNotFoundError(f"File for requested model {model_name} not found")
-            with open(model_file, 'r') as json_file:
-                print(f"USING MODEL (keras API): {model_file}")
-                loaded_model_json = json_file.read()
-
-            loaded_model = model_from_json(loaded_model_json)
-            loaded_model.load_weights(model_name + '.h5')
+        # if use_keras:
+        #    if os.path.isfile(os.path.join(caiman_datadir(), model_name + ".keras")):
+        #        model_file = os.path.join(caiman_datadir(), model_name + ".keras")
+        #    elif os.path.isfile(model_name + ".keras"):
+        #        model_file = model_name + ".keras"
+        #    else:
+        #        raise FileNotFoundError(f"File for requested model {model_name} not found")
+        #    
+        #    print(f"USING MODEL (keras API): {model_file}")
+        #    loaded_model = model_load(model_file)
+        #else:
+        if os.path.isfile(os.path.join(caiman_datadir(), model_name + ".pt")):
+            model_file = os.path.join(caiman_datadir(), model_name + ".pt")
+        elif os.path.isfile(model_name + ".pt"):
+            model_file = model_name + ".pt"
         else:
-            if os.path.isfile(os.path.join(caiman_datadir(), model_name + ".h5.pb")):
-                model_file = os.path.join(caiman_datadir(), model_name + ".h5.pb")
-            elif os.path.isfile(model_name + ".h5.pb"):
-                model_file = model_name + ".h5.pb"
-            else:
-                raise FileNotFoundError(f"File for requested model {model_name} not found")
-            print(f"USING MODEL (tensorflow API): {model_file}")
-            loaded_model = caiman.utils.utils.load_graph(model_file)
+            raise FileNotFoundError(f"File for requested model {model_name} not found")
+        print(f"USING MODEL (PyTorch API): {model_file}")
+        loaded_model = torch.load(model_file)
 
-        logger.debug("Loaded model from disk")
+        logging.debug("Loaded model from disk")
 
     half_crop = np.minimum(gSig[0] * 4 + 1, patch_size), np.minimum(gSig[1] * 4 + 1, patch_size)
     dims = np.array(dims)
@@ -320,14 +315,14 @@ def evaluate_components_CNN(A,
                                               half_crop[1]:com[1] + half_crop[1]] for mm, com in zip(A.tocsc().T, coms)
     ]
     final_crops = np.array([cv2.resize(im / np.linalg.norm(im), (patch_size, patch_size)) for im in crop_imgs])
-    if use_keras:
-        predictions = loaded_model.predict(final_crops[:, :, :, np.newaxis], batch_size=32, verbose=1)
-    else:
-        tf_in = loaded_model.get_tensor_by_name('prefix/conv2d_20_input:0')
-        tf_out = loaded_model.get_tensor_by_name('prefix/output_node0:0')
-        with tf.Session(graph=loaded_model) as sess:
-            predictions = sess.run(tf_out, feed_dict={tf_in: final_crops[:, :, :, np.newaxis]})
-            sess.close()
+    # if use_keras:
+    #    predictions = loaded_model.predict(final_crops[:, :, :, np.newaxis], batch_size=32, verbose=1)
+    # else:
+    final_crops = torch.tensor(final_crops, dtype=torch.float32)
+    final_crops = torch.reshape(final_crops, (-1, final_crops.shape[-1], 
+                    final_crops.shape[1], final_crops.shape[2])) 
+    with torch.no_grad():
+        predictions = loaded_model(final_crops[:, np.newaxis, :, :])
 
     return predictions, final_crops
 
diff --git a/caiman/source_extraction/cnmf/online_cnmf.py b/caiman/source_extraction/cnmf/online_cnmf.py
index 55b2828ba..2e008fae0 100644
--- a/caiman/source_extraction/cnmf/online_cnmf.py
+++ b/caiman/source_extraction/cnmf/online_cnmf.py
@@ -13,6 +13,9 @@
 imaging data in real time. In Advances in Neural Information Processing Systems 
 (pp. 2381-2391).
 @url http://papers.nips.cc/paper/6832-onacid-online-analysis-of-calcium-imaging-data-in-real-time
+
+Implemented in PyTorch
+Date: January 7th, 2025
 """
 
 import cv2
@@ -26,7 +29,7 @@
 from scipy.stats import norm
 from sklearn.decomposition import NMF
 from sklearn.preprocessing import normalize
-import tensorflow as tf
+import torch 
 from time import time
 
 import caiman
@@ -320,34 +323,27 @@ def _prepare_object(self, Yr, T, new_dims=None, idx_components=None):
         if self.params.get('online', 'path_to_model') is None or self.params.get('online', 'sniper_mode') is False:
             loaded_model = None
             self.params.set('online', {'sniper_mode': False})
-            self.tf_in = None
-            self.tf_out = None
+            # self.tf_in = None
+            # self.tf_out = None
         else:
-            try:
-                from tensorflow.keras.models import model_from_json
-                logger.info('Using Keras')
-                use_keras = True
-            except(ModuleNotFoundError):
-                use_keras = False
-                logger.info('Using Tensorflow')
-            if use_keras:
-                path = self.params.get('online', 'path_to_model').split(".")[:-1]
-                json_path = ".".join(path + ["json"])
-                model_path = ".".join(path + ["h5"])
-                json_file = open(json_path, 'r')
-                loaded_model_json = json_file.read()
-                json_file.close()
-                loaded_model = model_from_json(loaded_model_json)
-                loaded_model.load_weights(model_path)
-                self.tf_in = None
-                self.tf_out = None
-            else:
-                path = self.params.get('online', 'path_to_model').split(".")[:-1]
-                model_path = '.'.join(path + ['h5', 'pb'])
-                loaded_model = load_graph(model_path)
-                self.tf_in = loaded_model.get_tensor_by_name('prefix/conv2d_1_input:0')
-                self.tf_out = loaded_model.get_tensor_by_name('prefix/output_node0:0')
-                loaded_model = tf.Session(graph=loaded_model)
+            # try: 
+                # from keras.models import load_model 
+            #    use_keras = True
+            #    logging.info('Using Keras')
+            #    use_keras = True
+            # except(ModuleNotFoundError):
+            # use_keras = False 
+            logging.info('Using Torch')
+
+            path = self.params.get('online', 'path_to_model').split(".")[:-1]
+            # if use_keras:
+            #    model_path = ".".join(path + ["keras"])
+            #    loaded_model = model_load(model_path)
+            
+            model_path = '.'.join(path + ['pt'])
+            loaded_model = load_graph(model_path)
+            # loaded_model = torch.load(model_file)
+
         self.loaded_model = loaded_model
 
         if self.is1p:
@@ -548,7 +544,7 @@ def fit_next(self, t, frame_in, num_iters_hals=3):
                 sniper_mode=self.params.get('online', 'sniper_mode'),
                 use_peak_max=self.params.get('online', 'use_peak_max'),
                 mean_buff=self.estimates.mean_buff,
-                tf_in=self.tf_in, tf_out=self.tf_out,
+                # tf_in=self.tf_in, tf_out=self.tf_out,
                 ssub_B=ssub_B, W=self.estimates.W if self.is1p else None,
                 b0=self.estimates.b0 if self.is1p else None,
                 corr_img=self.estimates.corr_img if use_corr else None,
@@ -2002,8 +1998,9 @@ def get_candidate_components(sv, dims, Yres_buf, min_num_trial=3, gSig=(5, 5),
                              gHalf=(5, 5), sniper_mode=True, rval_thr=0.85,
                              patch_size=50, loaded_model=None, test_both=False,
                              thresh_CNN_noisy=0.5, use_peak_max=False,
-                             thresh_std_peak_resid = 1, mean_buff=None,
-                             tf_in=None, tf_out=None):
+                             thresh_std_peak_resid = 1, mean_buff=None #,
+                             ): # tf_in=None, tf_out=None):
+
     """
     Extract new candidate components from the residual buffer and test them
     using space correlation or the CNN classifier. The function runs the CNN
@@ -2084,12 +2081,18 @@ def get_candidate_components(sv, dims, Yres_buf, min_num_trial=3, gSig=(5, 5),
         Ain2 /= np.std(Ain2,axis=1)[:,None]
         Ain2 = np.reshape(Ain2,(-1,) + tuple(np.diff(ijSig_cnn).squeeze()),order= 'F')
         Ain2 = np.stack([cv2.resize(ain,(patch_size ,patch_size)) for ain in Ain2])
-        if tf_in is None:
-            predictions = loaded_model.predict(Ain2[:,:,:,np.newaxis], batch_size=min_num_trial, verbose=0)
-        else:
-            predictions = loaded_model.run(tf_out, feed_dict={tf_in: Ain2[:, :, :, np.newaxis]})
-        keep_cnn = list(np.where(predictions[:, 0] > thresh_CNN_noisy)[0])
-        cnn_pos = Ain2[keep_cnn]
+        # if use_torch is None:
+        #    predictions = loaded_model.predict(Ain2[:,:,:,np.newaxis], batch_size=min_num_trial, verbose=0)
+        #    keep_cnn = list(np.where(predictions[:, 0] > thresh_CNN_noisy)[0])
+        # else:
+        final_crops = torch.tensor(Ain2, dtype=torch.float32)
+        final_crops = torch.reshape(Ain2, (-1, Ain2.shape[-1], 
+                    Ain2.shape[1], Ain2.shape[2])) 
+        with torch.no_grad():
+            predictions = loaded_model(Ain2[:, np.newaxis, :, :])     
+            keep_cnn = list(torch.where(predictions[:, 0] > thresh_CNN_noisy)[0])
+        
+        cnn_pos = Ain2[keep_cnn] #Make sure this works 
     else:
         keep_cnn = []  # list(range(len(Ain_cnn)))
 
@@ -2138,7 +2141,8 @@ def update_num_components(t, sv, Ab, Cf, Yres_buf, Y_buf, rho_buf,
                           corr_img=None, first_moment=None, second_moment=None,
                           crosscorr=None, col_ind=None, row_ind=None, corr_img_mode=None,
                           max_img=None, downscale_matrix=None, upscale_matrix=None,
-                          tf_in=None, tf_out=None):
+                          ): # tf_in=None, tf_out=None):
+
     """
     Checks for new components in the residual buffer and incorporates them if they pass the acceptance tests
     """
@@ -2168,7 +2172,7 @@ def update_num_components(t, sv, Ab, Cf, Yres_buf, Y_buf, rho_buf,
         sniper_mode=sniper_mode, rval_thr=rval_thr, patch_size=50,
         loaded_model=loaded_model, thresh_CNN_noisy=thresh_CNN_noisy,
         use_peak_max=use_peak_max, test_both=test_both, mean_buff=mean_buff,
-        tf_in=tf_in, tf_out=tf_out)
+        ) # tf_in=tf_in, tf_out=tf_out)
 
     ind_new_all = ijsig_all
 
diff --git a/caiman/tests/test_mrcnn_pytorch.py b/caiman/tests/test_mrcnn_pytorch.py
new file mode 100644
index 000000000..883f6d76c
--- /dev/null
+++ b/caiman/tests/test_mrcnn_pytorch.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+
+import numpy as np
+import os
+import torch
+
+import caiman as cm
+from caiman.paths import caiman_datadir
+from caiman.utils.utils import download_model, download_demo
+from caiman.source_extraction.volpy.mrcnn import neurons
+import caiman.source_extraction.volpy.mrcnn.model as modellib
+
+def mrcnn(img, size_range, weights_path):
+
+    return 
+
+def test_mrcnn():
+    weights_path = download_model('mask_rcnn')    
+    summary_images = cm.load(download_demo('demo_voltage_imaging_summary_images.tif'))
+    ROIs = mrcnn(img=summary_images.transpose([1, 2, 0]), size_range=[5, 22],
+                                 weights_path=weights_path)
+    assert ROIs.shape[0] == 14, 'fail to infer correct number of neurons'
\ No newline at end of file
diff --git a/caiman/tests/test_pytorch.py b/caiman/tests/test_pytorch.py
new file mode 100644
index 000000000..aa09f416b
--- /dev/null
+++ b/caiman/tests/test_pytorch.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+import numpy as np
+import os
+
+from caiman.paths import caiman_datadir
+from caiman.utils.utils import load_graph
+
+import torch 
+
+def test_torch():
+    os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+
+    try:
+        model_name = os.path.join(caiman_datadir(), 'model', 'cnn_model')
+        # if use_keras:
+        #    model_file = model_name + ".keras"
+        #    print('USING MODEL:' + model_file)
+        #
+        #    loaded_model = load_model(model_file)
+        #    loaded_model.compile('sgd', 'mse')
+        # elif use_keras == True: 
+        model_file = model_name + ".pth"
+        loaded_model = torch.load(model_file)
+    except:
+        raise Exception(f'NN model could not be loaded.') #use_keras = {use_keras}')
+
+    A = np.random.randn(10, 50, 50, 1)
+    try:
+        # if use_keras == False: 
+        #     predictions = loaded_model.predict(A, batch_size=32)
+        # elif use_keras == True:
+        A = torch.tensor(A, dtype=torch.float32)
+        A = torch.reshape(A, (-1, A.shape[-1], A.shape[1], A.shape[2])) 
+        with torch.no_grad():
+            predictions = loaded_model(A)  
+        # pass 
+    except:
+        raise Exception('NN model could not be deployed.') #use_keras = + str(use_keras))
+
+if __name__ == "__main__":
+    test_torch()
\ No newline at end of file
diff --git a/caiman/train/__init__.py b/caiman/train/__init__.py
new file mode 100644
index 000000000..8700f901b
--- /dev/null
+++ b/caiman/train/__init__.py
@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+import pkg_resources
+
+from caiman.train.helper import cnn_model_pytorch, get_batch_accuracy, load_model_pytorch 
+from caiman.train.helper import save_model_pytorch, train_test_split, train, validate 
+
+__version__ = pkg_resources.get_distribution('caiman').version
\ No newline at end of file
diff --git a/caiman/train/ground_truth_cnmf_seeded.ipynb b/caiman/train/ground_truth_cnmf_seeded.ipynb
new file mode 100644
index 000000000..d914f7798
--- /dev/null
+++ b/caiman/train/ground_truth_cnmf_seeded.ipynb
@@ -0,0 +1,725 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Prepare ground truth built by matching with the results of CNMF\n",
+    "\n",
+    "User/programmer guide to understand and try the code. Currently being retooled. \n",
+    "\n",
+    "Details:    all of other usefull functions (demos available on jupyter notebook) \n",
+    "-*- coding: utf-8 -*-\n",
+    "\n",
+    "Version:   1.0\n",
+    "\n",
+    "Copyright: GNU General Public License v2.0\n",
+    "\n",
+    "Created on Mon Nov 21 15:53:15 2016\n",
+    "\n",
+    "Updated on Thu Jan 09 13:50:00 2025\n",
+    "\n",
+    "Authors: agiovann, mpaez"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "import scipy \n",
+    "\n",
+    "import caiman as cm\n",
+    "from caiman.utils.utils import download_demo\n",
+    "from caiman.base.rois import extract_binary_masks_blob\n",
+    "from caiman.utils.visualization import plot_contours, view_patches_bar\n",
+    "from caiman.source_extraction.cnmf import cnmf as cnmf\n",
+    "from caiman.motion_correction import MotionCorrect, tile_and_correct, motion_correction_piecewise \n",
+    "from caiman.components_evaluation import estimate_components_quality, evaluate_components\n",
+    "from caiman.tests.comparison import comparison"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading up the Ground Truth Files "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# neurofinder.03.00.test\n",
+    "params_movie = {'fname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_03_00/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_.mmap'],\n",
+    "                'gtname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_03_00/joined_consensus_active_regions.npy'],\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "                'final_frate': 10,\n",
+    "                #                 'r_values_min_patch': .7,  # threshold on space consistency\n",
+    "                #                 'fitness_min_patch': -20,  # threshold on time variability\n",
+    "                #                 # threshold on time variability (if nonsparse activity)\n",
+    "                #                 'fitness_delta_min_patch': -20,\n",
+    "                #                 'Npeaks': 10,\n",
+    "                #                 'r_values_min_full': .8,\n",
+    "                #                 'fitness_min_full': - 40,\n",
+    "                #                 'fitness_delta_min_full': - 40,\n",
+    "                #                 'only_init_patch': True,\n",
+    "                'gnb': 1,\n",
+    "                #                 'memory_fact': 1,\n",
+    "                #                 'n_chunks': 10,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                'swap_dim': False  # for some movies needed\n",
+    "                }\n",
+    "\n",
+    "# neurofinder.04.00.test\n",
+    "params_movie = {'fname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_04_00_test/Yr_d1_512_d2_512_d3_1_order_C_frames_3000_.mmap'],\n",
+    "                'gtname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_04_00_test/joined_consensus_active_regions.npy'],\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "                'final_frate': 10,\n",
+    "                #                 'r_values_min_patch': .7,  # threshold on space consistency\n",
+    "                #                 'fitness_min_patch': -20,  # threshold on time variability\n",
+    "                #                 # threshold on time variability (if nonsparse activity)\n",
+    "                #                 'fitness_delta_min_patch': -20,\n",
+    "                #                 'Npeaks': 10,\n",
+    "                #                 'r_values_min_full': .8,\n",
+    "                #                 'fitness_min_full': - 40,\n",
+    "                #                 'fitness_delta_min_full': - 40,\n",
+    "                #                 'only_init_patch': True,\n",
+    "                'gnb': 1,\n",
+    "                #                 'memory_fact': 1,\n",
+    "                #                 'n_chunks': 10,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                'swap_dim': False  # for some movies needed\n",
+    "\n",
+    "                }\n",
+    "\n",
+    "# Yi not clear neurons\n",
+    "params_movie = {'fname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/Yi_data_001/Yr_d1_512_d2_512_d3_1_order_C_frames_7826_.mmap'],\n",
+    "                'gtname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/Yi_data_001/joined_consensus_active_regions.npy'],\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "                'final_frate': 30,\n",
+    "                #                 'r_values_min_patch': .7,  # threshold on space consistency\n",
+    "                #                 'fitness_min_patch': -20,  # threshold on time variability\n",
+    "                #                 # threshold on time variability (if nonsparse activity)\n",
+    "                #                 'fitness_delta_min_patch': -20,\n",
+    "                #                 'Npeaks': 10,\n",
+    "                #                 'r_values_min_full': .8,\n",
+    "                #                 'fitness_min_full': - 40,\n",
+    "                #                 'fitness_delta_min_full': - 40,\n",
+    "                #                 'only_init_patch': True,\n",
+    "                'gnb': 1,\n",
+    "                #                 'memory_fact': 1,\n",
+    "                #                 'n_chunks': 10,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                }\n",
+    "\n",
+    "# neurofinder.02.00\n",
+    "params_movie = {'fname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_02_01/Yr_d1_512_d2_512_d3_1_order_C_frames_8000_.mmap'],\n",
+    "                'gtname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_02_01/joined_consensus_active_regions.npy'],\n",
+    "                'merge_thresh': .8,  # merging threshold, max correlation allow\n",
+    "                'final_frate': 10,\n",
+    "                'gnb': 1,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                                     #(to be used with one background per patch)\n",
+    "                'swap_dim': False  # for some movies needed\n",
+    "                }\n",
+    "\n",
+    "# yuste: used kernel = np.ones((radius//4,radius//4),np.uint8)\n",
+    "params_movie = {'fname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/yuste_single_150u/Yr_d1_200_d2_256_d3_1_order_C_frames_3000_.mmap'],\n",
+    "                'gtname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/yuste_single_150/joined_consensus_active_regions.npy'],\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "                'final_frate': 10,\n",
+    "                'gnb': 1,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                'swap_dim': False  # for some movies needed\n",
+    "                }\n",
+    "\n",
+    "# neurofinder 00 00\n",
+    "params_movie = {'fname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_00_00/Yr_d1_512_d2_512_d3_1_order_C_frames_2936_.mmap'],\n",
+    "                'gtname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_00_00/joined_consensus_active_regions.npy'],\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "                'final_frate': 10,\n",
+    "                #                 'r_values_min_patch': .7,  # threshold on space consistency\n",
+    "                #                 'fitness_min_patch': -20,  # threshold on time variability\n",
+    "                #                 # threshold on time variability (if nonsparse activity)\n",
+    "                #                 'fitness_delta_min_patch': -20,\n",
+    "                #                 'Npeaks': 10,\n",
+    "                #                 'r_values_min_full': .8,\n",
+    "                #                 'fitness_min_full': - 40,\n",
+    "                #                 'fitness_delta_min_full': - 40,\n",
+    "                #                 'only_init_patch': True,\n",
+    "                'gnb': 1,\n",
+    "                #                 'memory_fact': 1,\n",
+    "                #                 'n_chunks': 10,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                'swap_dim': False  # for some movies needed\n",
+    "                }\n",
+    "\n",
+    "# k53\n",
+    "# params_movie = {'fname': ['/mnt/ceph/data/neuro/caiman/labeling/k53_20160530/final_map/Yr_d1_512_d2_512_d3_1_order_C_frames_116043_.mmap'],\n",
+    "#                'gtname': ['/mnt/ceph/data/neuro/caiman/labeling/k53_20160530/regions/joined_consensus_active_regions.npy'],\n",
+    "#                'seed_name': ['/mnt/ceph/data/neuro/caiman/labeling/k53_20160530/regions/joined_consensus_active_regions.npy'],\n",
+    "#                'p': 1,  # order of the autoregressive system\n",
+    "#                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "#                'final_frate': 30,\n",
+    "#                'gnb': 1,\n",
+    "#                # whether to update the background components in the spatial phase\n",
+    "#                'update_background_components': True,\n",
+    "#                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "#                #(to be used with one background per patch)\n",
+    "#                'swap_dim': False,  # for some movies needed\n",
+    "#                'kernel': None\n",
+    "#                }\n",
+    "\n",
+    "# neurofinder: 01.01\n",
+    "params_movie = {'fname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_01_01/Yr_d1_512_d2_512_d3_1_order_C_frames_1825_.mmap'],\n",
+    "                'gtname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_01_01/joined_consensus_active_regions.npy'],\n",
+    "                'seed_name': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_01_01/joined_consensus_active_regions.npy'],\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "                'final_frate': 10,\n",
+    "                'gnb': 1,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                'swap_dim': False,  # for some movies needed\n",
+    "                'kernel': None\n",
+    "                }\n",
+    "\n",
+    "# J115: 01.01\n",
+    "# params_movie = {'fname': ['/mnt/ceph/data/neuro/caiman/labeling/J115_2015-12-09_L01_ELS/images/final_map/Yr_d1_463_d2_472_d3_1_order_C_frames_90000_.mmap'],\n",
+    "#                'gtname': ['/mnt/ceph/data/neuro/caiman/labeling/J115_2015-12-09_L01_ELS/regions/joined_consensus_active_regions.npy'],\n",
+    "#                'seed_name': ['/mnt/ceph/data/neuro/caiman/labeling/J115_2015-12-09_L01_ELS/regions/joined_consensus_active_regions.npy'],\n",
+    "#                'p': 1,  # order of the autoregressive system\n",
+    "#                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "#                'final_frate': 10,\n",
+    "#                'gnb': 1,\n",
+    "#                # whether to update the background components in the spatial phase\n",
+    "#                'update_background_components': True,\n",
+    "#                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "#                #(to be used with one background per patch)\n",
+    "#                'swap_dim': False,  # for some movies needed\n",
+    "#                'kernel': None\n",
+    "#                }\n",
+    "\n",
+    "# J123\n",
+    "params_movie = {'fname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/J123/Yr_d1_458_d2_477_d3_1_order_C_frames_41000_.mmap'],\n",
+    "                'gtname': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/J123/joined_consensus_active_regions.npy'],\n",
+    "                'seed_name': ['/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/J123/joined_consensus_active_regions.npy'],\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "                'final_frate': 10,\n",
+    "                'gnb': 1,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                'swap_dim': False,  # for some movies needed\n",
+    "                'kernel': None\n",
+    "                }\n",
+    "# Jan-AMG\n",
+    "# params_movie = {'fname': ['/mnt/ceph/data/neuro/caiman/labeling/Jan-AMG_exp3_001/images/final_map/Yr_d1_512_d2_512_d3_1_order_C_frames_115897_.mmap'],\n",
+    "#                'gtname': ['/mnt/ceph/data/neuro/caiman/labeling/Jan-AMG_exp3_001/regions/joined_consensus_active_regions.npy'],\n",
+    "#                'seed_name': ['/mnt/ceph/data/neuro/caiman/labeling/Jan-AMG_exp3_001/regions/joined_consensus_active_regions.npy'],\n",
+    "#                'p': 1,  # order of the autoregressive system\n",
+    "#                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "#                'final_frate': 10,\n",
+    "#                'gnb': 1,\n",
+    "#                # whether to update the background components in the spatial phase\n",
+    "#                'update_background_components': True,\n",
+    "#                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "#                #(to be used with one background per patch)\n",
+    "#                'swap_dim': False,  # for some movies needed\n",
+    "#                'kernel': None,\n",
+    "#                'crop_pix': 8,\n",
+    "#                }\n",
+    "\n",
+    "# sue k37, not nice because few events\n",
+    "# params_movie = {'fname': ['/mnt/ceph/data/neuro/caiman/labeling/k37_20160109_AM_150um_65mW_zoom2p2_00001_1-16/images/final_map/Yr_d1_512_d2_512_d3_1_order_C_frames_48000_.mmap'],\n",
+    "#                'gtname': ['/mnt/ceph/data/neuro/caiman/labeling/k37_20160109_AM_150um_65mW_zoom2p2_00001_1-16/regions/joined_consensus_active_regions.npy'],\n",
+    "#                'seed_name': ['/mnt/ceph/data/neuro/caiman/labeling/k37_20160109_AM_150um_65mW_zoom2p2_00001_1-16/regions/joined_consensus_active_regions.npy'],\n",
+    "#                'p': 1,  # order of the autoregressive system\n",
+    "#                'merge_thresh': 1,  # merging threshold, max correlation allow\n",
+    "#                'final_frate': 30,\n",
+    "#                'gnb': 2,\n",
+    "#                # whether to update the background components in the spatial phase\n",
+    "#                'update_background_components': True,\n",
+    "#                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "#                #(to be used with one background per patch)\n",
+    "#                'swap_dim': False,  # for some movies needed\n",
+    "#                'kernel': None,\n",
+    "#                'crop_pix': 7,\n",
+    "#                }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Parameters for the Movie"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params_display = {\n",
+    "    'downsample_ratio': .2,\n",
+    "    'thr_plot': 0.8\n",
+    "}\n",
+    "\n",
+    "# @params fname name of the movie\n",
+    "fname_new = params_movie['fname'][0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run Analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The local backend is an alias for the multiprocessing backend, and the alias may be removed in some future version of Caiman\n"
+     ]
+    }
+   ],
+   "source": [
+    "c, dview, n_processes = cm.cluster.setup_cluster(\n",
+    "    backend='local', n_processes=None, single_thread=False)\n",
+    "\n",
+    "Yr, dims, T = cm.load_memmap(fname_new)\n",
+    "d1, d2 = dims\n",
+    "images = np.reshape(Yr.T, [T] + list(dims), order='F')\n",
+    "Y = np.reshape(Yr, dims + (T,), order='F')\n",
+    "m_images = cm.movie(images)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Correlation Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "File request:[/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/projections/correlation_image_better.tif] not found!\n"
+     ]
+    },
+    {
+     "ename": "Exception",
+     "evalue": "File /Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/projections/correlation_image_better.tif not found!",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[5], line 7\u001b[0m\n\u001b[1;32m      4\u001b[0m     Cn[np\u001b[38;5;241m.\u001b[39misnan(Cn)] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m      6\u001b[0m     \u001b[38;5;66;03m#Saved as a tif file\u001b[39;00m\n\u001b[0;32m----> 7\u001b[0m     Cn \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(\u001b[43mcm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m/\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams_movie\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mgtname\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m/\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\n\u001b[1;32m      8\u001b[0m \u001b[43m                  \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mprojections\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mcorrelation_image_better.tif\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m)\u001b[38;5;241m.\u001b[39msqueeze() \n\u001b[1;32m     10\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(Cn, cmap\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgray\u001b[39m\u001b[38;5;124m'\u001b[39m, vmax\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.95\u001b[39m)\n",
+      "File \u001b[0;32m/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/base/movies.py:1540\u001b[0m, in \u001b[0;36mload\u001b[0;34m(file_name, fr, start_time, meta_data, subindices, shape, var_name_hdf5, in_memory, is_behavior, bottom, top, left, right, channel, outtype, is3D)\u001b[0m\n\u001b[1;32m   1538\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   1539\u001b[0m     logger\u001b[38;5;241m.\u001b[39merror(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFile request:[\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m] not found!\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 1540\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mFile \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m not found!\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m   1542\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m movie(input_arr\u001b[38;5;241m.\u001b[39mastype(outtype),\n\u001b[1;32m   1543\u001b[0m              fr\u001b[38;5;241m=\u001b[39mfr,\n\u001b[1;32m   1544\u001b[0m              start_time\u001b[38;5;241m=\u001b[39mstart_time,\n\u001b[1;32m   1545\u001b[0m              file_name\u001b[38;5;241m=\u001b[39mos\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39msplit(file_name)[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m],\n\u001b[1;32m   1546\u001b[0m              meta_data\u001b[38;5;241m=\u001b[39mmeta_data)\n",
+      "\u001b[0;31mException\u001b[0m: File /Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/projections/correlation_image_better.tif not found!"
+     ]
+    }
+   ],
+   "source": [
+    "if m_images.shape[0] < 10000:\n",
+    "    Cn = m_images.local_correlations(\n",
+    "        swap_dim=params_movie['swap_dim'], frames_per_chunk=1500)\n",
+    "    Cn[np.isnan(Cn)] = 0\n",
+    "else:\n",
+    "    Cn = np.array(cm.load(('/'.join(params_movie['gtname'][0].split('/')[:-2] + [\n",
+    "                  'projections', 'correlation_image_better.tif'])))).squeeze() \n",
+    "\n",
+    "plt.imshow(Cn, cmap='gray', vmax=.95)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9\n",
+      "(183, 458, 477)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x33c185f10>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if not '.mat' in params_movie['seed_name'][0]:\n",
+    "    roi_cons = np.load(params_movie['seed_name'][0])\n",
+    "else:\n",
+    "    roi_cons = scipy.io.loadmat(params_movie['seed_name'][0])['comps'].reshape(\n",
+    "        (dims[1], dims[0], -1), order='F').transpose([2, 1, 0]) * 1.\n",
+    "\n",
+    "radius = int(np.median(np.sqrt(np.sum(roi_cons, (1, 2)) / np.pi)))\n",
+    "\n",
+    "print(radius)\n",
+    "print(roi_cons.shape)\n",
+    "plt.imshow(roi_cons.sum(0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'Cn' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[7], line 11\u001b[0m\n\u001b[1;32m      8\u001b[0m A_in \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mreshape(roi_cons\u001b[38;5;241m.\u001b[39mtranspose(\n\u001b[1;32m      9\u001b[0m     [\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m0\u001b[39m]), (\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, roi_cons\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]), order\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m     10\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure()\n\u001b[0;32m---> 11\u001b[0m crd \u001b[38;5;241m=\u001b[39m plot_contours(A_in, \u001b[43mCn\u001b[49m, thr\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.99999\u001b[39m)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'Cn' is not defined"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if params_movie['kernel'] is not None:  # kernel usually two\n",
+    "    kernel = np.ones(\n",
+    "        (radius // params_movie['kernel'], radius // params_movie['kernel']), np.uint8)\n",
+    "    roi_cons = np.vstack([cv2.dilate(rr, kernel, iterations=1)[\n",
+    "                         np.newaxis, :, :] > 0 for rr in roi_cons]) * 1.\n",
+    "    pl.imshow(roi_cons.sum(0), alpha=0.5)\n",
+    "\n",
+    "A_in = np.reshape(roi_cons.transpose(\n",
+    "    [2, 1, 0]), (-1, roi_cons.shape[0]), order='C')\n",
+    "plt.figure()\n",
+    "crd = plot_contours(A_in, Cn, thr=.99999)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Parameter Setting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# order of the autoregressive fit to calcium imaging in general one (slow gcamps) or two (fast gcamps fast scanning)\n",
+    "p = params_movie['p']\n",
+    "# merging threshold, max correlation allowed\n",
+    "merge_thresh = params_movie['merge_thresh']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Extract spatial and temporal components on patches"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "spatial support for each components given by the user\n",
+      "estimating f\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n",
+      "/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/deconvolution.py:1004: FutureWarning: Beginning in SciPy 1.17, multidimensional input will be treated as a batch, not `ravel`ed. To preserve the existing behavior and silence this warning, `ravel` arguments before passing them to `toeplitz`.\n",
+      "  A = scipy.linalg.toeplitz(xc[lags + np.arange(lags)],\n"
+     ]
+    },
+    {
+     "ename": "AttributeError",
+     "evalue": "'CNMF' object has no attribute 'A'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[9], line 10\u001b[0m\n\u001b[1;32m      6\u001b[0m cnm \u001b[38;5;241m=\u001b[39m cnmf\u001b[38;5;241m.\u001b[39mCNMF(check_nan\u001b[38;5;241m=\u001b[39mcheck_nan, n_processes\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, k\u001b[38;5;241m=\u001b[39mA_in\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m], gSig\u001b[38;5;241m=\u001b[39m[radius, radius], merge_thresh\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmerge_thresh\u001b[39m\u001b[38;5;124m'\u001b[39m], p\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mp\u001b[39m\u001b[38;5;124m'\u001b[39m], Ain\u001b[38;5;241m=\u001b[39mA_in\u001b[38;5;241m.\u001b[39mastype(\u001b[38;5;28mbool\u001b[39m),\n\u001b[1;32m      7\u001b[0m                 dview\u001b[38;5;241m=\u001b[39mdview, rf\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, stride\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, gnb\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgnb\u001b[39m\u001b[38;5;124m'\u001b[39m], method_deconvolution\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124moasis\u001b[39m\u001b[38;5;124m'\u001b[39m, border_pix\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m, low_rank_background\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlow_rank_background\u001b[39m\u001b[38;5;124m'\u001b[39m], n_pixels_per_process\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1000\u001b[39m)\n\u001b[1;32m      8\u001b[0m cnm \u001b[38;5;241m=\u001b[39m cnm\u001b[38;5;241m.\u001b[39mfit(images)\n\u001b[0;32m---> 10\u001b[0m A \u001b[38;5;241m=\u001b[39m \u001b[43mcnm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m\n\u001b[1;32m     11\u001b[0m C \u001b[38;5;241m=\u001b[39m cnm\u001b[38;5;241m.\u001b[39mC\n\u001b[1;32m     12\u001b[0m YrA \u001b[38;5;241m=\u001b[39m cnm\u001b[38;5;241m.\u001b[39mYrA\n",
+      "\u001b[0;31mAttributeError\u001b[0m: 'CNMF' object has no attribute 'A'"
+     ]
+    }
+   ],
+   "source": [
+    "if images.shape[0] > 10000:\n",
+    "    check_nan = False\n",
+    "else:\n",
+    "    check_nan = True\n",
+    "\n",
+    "cnm = cnmf.CNMF(check_nan=check_nan, n_processes=1, k=A_in.shape[-1], gSig=[radius, radius], merge_thresh=params_movie['merge_thresh'], p=params_movie['p'], Ain=A_in.astype(bool),\n",
+    "                dview=dview, rf=None, stride=None, gnb=params_movie['gnb'], method_deconvolution='oasis', border_pix=0, low_rank_background=params_movie['low_rank_background'], n_pixels_per_process=1000)\n",
+    "cnm = cnm.fit(images)\n",
+    "\n",
+    "A = cnm.A\n",
+    "C = cnm.C\n",
+    "YrA = cnm.YrA\n",
+    "b = cnm.b\n",
+    "f = cnm.f\n",
+    "snt = cnm.sn\n",
+    "print(('Number of components:' + str(A.shape[-1])))\n",
+    "plt.figure()\n",
+    "crd = plot_contours(A, Cn, thr=params_display['thr_plot'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Threshold Components "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'A' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[15], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# TODO: needinfo\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m view_patches_bar(Yr, scipy\u001b[38;5;241m.\u001b[39msparse\u001b[38;5;241m.\u001b[39mcoo_matrix(\u001b[43mA\u001b[49m\u001b[38;5;241m.\u001b[39mtocsc()[:, :]), C[:, :], b, f, dims[\u001b[38;5;241m0\u001b[39m], dims[\u001b[38;5;241m1\u001b[39m],\n\u001b[1;32m      3\u001b[0m                  YrA\u001b[38;5;241m=\u001b[39mYrA[:, :], img\u001b[38;5;241m=\u001b[39mCn)\n\u001b[1;32m      5\u001b[0m c, dview, n_processes \u001b[38;5;241m=\u001b[39m cm\u001b[38;5;241m.\u001b[39mcluster\u001b[38;5;241m.\u001b[39msetup_cluster(\n\u001b[1;32m      6\u001b[0m     backend\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlocal\u001b[39m\u001b[38;5;124m'\u001b[39m, n_processes\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, single_thread\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m      8\u001b[0m min_size_neuro \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m np\u001b[38;5;241m.\u001b[39mpi\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'A' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# TODO: needinfo\n",
+    "view_patches_bar(Yr, scipy.sparse.coo_matrix(A.tocsc()[:, :]), C[:, :], b, f, dims[0], dims[1],\n",
+    "                 YrA=YrA[:, :], img=Cn)\n",
+    "\n",
+    "c, dview, n_processes = cm.cluster.setup_cluster(\n",
+    "    backend='local', n_processes=None, single_thread=False)\n",
+    "\n",
+    "min_size_neuro = 3 * 2 * np.pi\n",
+    "max_size_neuro = (2 * radius)**2 * np.pi\n",
+    "A_thr = cm.source_extraction.cnmf.spatial.threshold_components(A.tocsc()[:, :].toarray(), dims, medw=None, thr_method='max', maxthr=0.2, nrgthr=0.99, extract_cc=True,\n",
+    "                                                               se=None, ss=None, dview=dview)\n",
+    "\n",
+    "A_thr = A_thr > 0\n",
+    "size_neurons = A_thr.sum(0)\n",
+    "idx_size_neuro = np.where((size_neurons > min_size_neuro)\n",
+    "                          & (size_neurons < max_size_neuro))[0]\n",
+    "A_thr = A_thr[:, idx_size_neuro]\n",
+    "print(A_thr.shape)\n",
+    "\n",
+    "crd = plot_contours(scipy.sparse.coo_matrix(\n",
+    "    A_thr * 1.), Cn, thr=.99, vmax=0.35)\n",
+    "\n",
+    "roi_cons = np.load(params_movie['gtname'][0])\n",
+    "print(roi_cons.shape)\n",
+    "plt.imshow(roi_cons.sum(0))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Compare CNMF Seeded with ground truth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'A_thr' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[11], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m30\u001b[39m, \u001b[38;5;241m20\u001b[39m))\n\u001b[0;32m----> 2\u001b[0m tp_gt, tp_comp, fn_gt, fp_comp, performance_cons_off \u001b[38;5;241m=\u001b[39m cm\u001b[38;5;241m.\u001b[39mbase\u001b[38;5;241m.\u001b[39mrois\u001b[38;5;241m.\u001b[39mnf_match_neurons_in_binary_masks(roi_cons, \u001b[43mA_thr\u001b[49m[:, :]\u001b[38;5;241m.\u001b[39mreshape([dims[\u001b[38;5;241m0\u001b[39m], dims[\u001b[38;5;241m1\u001b[39m], \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m], order\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mF\u001b[39m\u001b[38;5;124m'\u001b[39m)\u001b[38;5;241m.\u001b[39mtranspose([\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m]) \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m1.\u001b[39m, thresh_cost\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.7\u001b[39m, min_dist\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m,\n\u001b[1;32m      3\u001b[0m                                                                                                      print_assignment\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, plot_results\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, Cn\u001b[38;5;241m=\u001b[39mCn, labels\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mGT\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mOffline\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m      4\u001b[0m plt\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpdf.fonttype\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m42\u001b[39m\n\u001b[1;32m      5\u001b[0m font \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfamily\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mMyriad Pro\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m      6\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mweight\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mregular\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m      7\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msize\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;241m20\u001b[39m}\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'A_thr' is not defined"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 3000x2000 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(30, 20))\n",
+    "tp_gt, tp_comp, fn_gt, fp_comp, performance_cons_off = cm.base.rois.nf_match_neurons_in_binary_masks(roi_cons, A_thr[:, :].reshape([dims[0], dims[1], -1], order='F').transpose([2, 0, 1]) * 1., thresh_cost=.7, min_dist=10,\n",
+    "                                                                                                     print_assignment=False, plot_results=False, Cn=Cn, labels=['GT', 'Offline'])\n",
+    "plt.rcParams['pdf.fonttype'] = 42\n",
+    "font = {'family': 'Myriad Pro',\n",
+    "        'weight': 'regular',\n",
+    "        'size': 20}\n",
+    "plt.rc('font', **font)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generating match_masks.npz"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'Cn' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[12], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m np\u001b[38;5;241m.\u001b[39msavez(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39msplit(fname_new)[\u001b[38;5;241m0\u001b[39m], os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39msplit(fname_new)[\u001b[38;5;241m1\u001b[39m][:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m4\u001b[39m] \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmatch_masks.npz\u001b[39m\u001b[38;5;124m'\u001b[39m), Cn\u001b[38;5;241m=\u001b[39m\u001b[43mCn\u001b[49m,\n\u001b[1;32m      2\u001b[0m          tp_gt\u001b[38;5;241m=\u001b[39mtp_gt, tp_comp\u001b[38;5;241m=\u001b[39mtp_comp, fn_gt\u001b[38;5;241m=\u001b[39mfn_gt, fp_comp\u001b[38;5;241m=\u001b[39mfp_comp, performance_cons_off\u001b[38;5;241m=\u001b[39mperformance_cons_off, idx_size_neuro_gt\u001b[38;5;241m=\u001b[39midx_size_neuro, A_thr\u001b[38;5;241m=\u001b[39mA_thr,\n\u001b[1;32m      3\u001b[0m          A_gt\u001b[38;5;241m=\u001b[39mA, C_gt\u001b[38;5;241m=\u001b[39mC, b_gt\u001b[38;5;241m=\u001b[39mb, f_gt\u001b[38;5;241m=\u001b[39mf, YrA_gt\u001b[38;5;241m=\u001b[39mYrA, d1\u001b[38;5;241m=\u001b[39md1, d2\u001b[38;5;241m=\u001b[39md2, idx_components_gt\u001b[38;5;241m=\u001b[39midx_size_neuro[\n\u001b[1;32m      4\u001b[0m              tp_comp],\n\u001b[1;32m      5\u001b[0m          idx_components_bad_gt\u001b[38;5;241m=\u001b[39midx_size_neuro[fp_comp], fname_new\u001b[38;5;241m=\u001b[39mfname_new)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'Cn' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "np.savez(os.path.join(os.path.split(fname_new)[0], os.path.split(fname_new)[1][:-4] + 'match_masks.npz'), Cn=Cn,\n",
+    "         tp_gt=tp_gt, tp_comp=tp_comp, fn_gt=fn_gt, fp_comp=fp_comp, performance_cons_off=performance_cons_off, idx_size_neuro_gt=idx_size_neuro, A_thr=A_thr,\n",
+    "         A_gt=A, C_gt=C, b_gt=b, f_gt=f, YrA_gt=YrA, d1=d1, d2=d2, idx_components_gt=idx_size_neuro[\n",
+    "             tp_comp],\n",
+    "         idx_components_bad_gt=idx_size_neuro[fp_comp], fname_new=fname_new)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "caiman_pytorch_2",
+   "language": "python",
+   "name": "caiman_pytorch_2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/caiman/train/helper.py b/caiman/train/helper.py
new file mode 100644
index 000000000..dc914ef2e
--- /dev/null
+++ b/caiman/train/helper.py
@@ -0,0 +1,131 @@
+import numpy as np
+import os
+import keras 
+from keras.layers import Input, Conv2D, Activation, MaxPooling2D, Dropout, Flatten, Dense 
+from keras.models import save_model, load_model 
+from sklearn.model_selection import train_test_split
+from sklearn.utils import class_weight as cw
+import torch 
+import torch.nn as nn 
+import torch.nn.functional as F
+from torch.utils.data import Dataset, random_split 
+
+import caiman as cm
+from caiman.paths import caiman_datadir
+from caiman.utils.image_preprocessing_keras import ImageDataGenerator
+
+os.environ["KERAS_BACKEND"] = "torch"
+
+class cnn_model_pytorch(torch.nn.Module): 
+    def __init__(self, in_channels, num_classes):
+        super(cnn_model_pytorch, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=32, kernel_size=(3,3), stride=(1, 1))
+        self.conv2 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=(3,3), stride=(1, 1))
+        self.maxpool2d1 = nn.MaxPool2d(kernel_size=(2, 2))
+        self.conv3 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=(3,3), stride=(1, 1), padding='same')
+        self.conv4 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=(3,3), stride=(1, 1))
+        self.maxpool2d2 = nn.MaxPool2d(kernel_size=(2, 2))
+        self.flatten = nn.Flatten()
+        self.dense1 = nn.Linear(in_features=6400, out_features=512)
+        self.dense2 = nn.Linear(in_features=512, out_features=num_classes)
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = F.dropout(self.maxpool2d1(x))
+        x = F.relu(self.conv3(x))
+        x = F.relu(self.conv4(x))
+        x = F.dropout(self.maxpool2d2(x), p=0.25)
+        x = self.flatten(x)
+        x = F.relu(self.dense1(x))
+        x = F.dropout(x, p=0.5)
+        x = F.softmax(self.dense2(x), dim=1)
+        return x 
+
+def save_model_pytorch(model, name: str):
+    model_name = os.path.join(caiman_datadir(), 'model', name)
+    model_path = model_name + ".pth"
+    torch.save(model, model_path)
+    print('Saved trained model at %s ' % model_path)
+    return model_path 
+
+def load_model_pytorch(model_path: str):
+    load_model = torch.load(model_path)
+    print('Load trained model at %s ' % model_path)
+    return load_model  
+
+def train_test_split(dataset: Dataset, test_fraction: float):
+    train_ratio = 1 - test_fraction
+    train_size = int(train_ratio * len(dataset))
+    test_size = len(dataset) - train_size
+    lengths = [train_size, test_size]
+    train_dataset, test_dataset = random_split(dataset, lengths)
+    return train_dataset, test_dataset
+
+def get_batch_accuracy(output, y, N):
+    pred = output.argmax(dim=1, keepdim=True)
+    correct = pred.eq(y.view_as(pred)).sum().item()
+    return correct / N
+
+def train(model, train_loader, loss_function, optimizer, train_N, augment):
+    loss = 0
+    accuracy = 0
+
+    model.train()
+    for x, y in train_loader:
+        output = model(x)  
+        optimizer.zero_grad()
+        batch_loss = loss_function(output, y)
+        batch_loss.backward()
+        optimizer.step()
+
+        loss += batch_loss.item()
+        accuracy += get_batch_accuracy(output, y, train_N)
+    print('Train - Loss: {:.4f} Accuracy: {:.4f}'.format(loss, accuracy))
+
+def validate(model, valid_loader, loss_function, optimizer, valid_N, augment):
+    loss = 0
+    accuracy = 0
+
+    model.eval()
+    with torch.no_grad():
+        for x, y in valid_loader:
+            output = model(x)
+
+            loss += loss_function(output, y).item()
+            accuracy += get_batch_accuracy(output, y, valid_N)
+    print('Valid - Loss: {:.4f} Accuracy: {:.4f}'.format(loss, accuracy))
+
+def cnn_model_keras(input_shape, num_classes): 
+    sequential_model = keras.Sequential([   
+        Input(shape=input_shape, dtype="float32"), 
+        Conv2D(filters=32, kernel_size=(3,3), strides=(1, 1), 
+        activation="relu"), 
+        Conv2D(filters=32, kernel_size=(3,3), strides=(1, 1), 
+        activation="relu"), 
+        MaxPooling2D(pool_size=(2, 2)), 
+        Dropout(rate=0.25),
+        Conv2D(filters=64, kernel_size=(3,3), strides=(1, 1), 
+        padding="same", activation="relu"),
+        Conv2D(filters=64, kernel_size=(3,3), strides=(1, 1), 
+        activation="relu"),  
+        MaxPooling2D(pool_size=(2, 2)), 
+        Dropout(rate=0.25),
+        Flatten(),
+        Dense(units=512, activation="relu"),
+        Dropout(rate=0.5),
+        Dense(units=num_classes, activation="relu"),
+    ])
+    return sequential_model 
+
+def save_model_keras(model, name: str):
+    model_name = os.path.join(caiman_datadir(), 'model', name)
+    model_path = model_name + ".keras"
+    model.save(model_path)
+    print('Saved trained model at %s ' % model_path)
+    return model_path 
+
+def load_model_keras(model_path: str):
+    loaded_model = load_model(model_path)
+    print('Load trained model at %s ' % model_path)
+    return loaded_model  
\ No newline at end of file
diff --git a/caiman/train/match_seeded_gt.ipynb b/caiman/train/match_seeded_gt.ipynb
new file mode 100644
index 000000000..9d15c5b27
--- /dev/null
+++ b/caiman/train/match_seeded_gt.ipynb
@@ -0,0 +1,722 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Matching the Cnmf-Seeded Components from Ground Truths with the Results of a CNMF Run"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import pylab as plt\n",
+    "from sklearn.preprocessing import normalize\n",
+    "import time\n",
+    "\n",
+    "import caiman as cm\n",
+    "from caiman.utils.utils import download_demo\n",
+    "from caiman.base.rois import extract_binary_masks_blob\n",
+    "from caiman.utils.visualization import plot_contours, view_patches_bar\n",
+    "from caiman.source_extraction.cnmf import cnmf as cnmf\n",
+    "from caiman.motion_correction import MotionCorrect, tile_and_correct, motion_correction_piecewise \n",
+    "from caiman.components_evaluation import estimate_components_quality, evaluate_components, evaluate_components_CNN\n",
+    "from caiman.tests.comparison import comparison"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Loading Up the Ground Truth Files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Neurofinder 03.00.test \n",
+    "params_movie = {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_03_00/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_.mmap',\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 0.8,  # merging threshold, max correlation allow\n",
+    "                'rf': 25,  # half-size of the patches in pixels. rf=25, patches are 50x50    20\n",
+    "                'stride_cnmf': 10,  # amounpl.it of overlap between the patches in pixels\n",
+    "                'K': 4,  # number of components per patch\n",
+    "                # if dendritic. In this case you need to set init_method to sparse_nmf\n",
+    "                'is_dendrites': False,\n",
+    "                'init_method': 'greedy_roi',\n",
+    "                'gSig': [8, 8],  # expected half size of neurons\n",
+    "                'alpha_snmf': None,  # this controls sparsity\n",
+    "                'final_frate': 10,\n",
+    "                'r_values_min_patch': .5,  # threshold on space consistency\n",
+    "                'fitness_min_patch': -10,  # threshold on time variability\n",
+    "                # threshold on time variability (if nonsparse activity)\n",
+    "                'fitness_delta_min_patch': -5,\n",
+    "                'Npeaks': 5,\n",
+    "                'r_values_min_full': .8,\n",
+    "                'fitness_min_full': - 40,\n",
+    "                'fitness_delta_min_full': - 40,\n",
+    "                'only_init_patch': True,\n",
+    "                'gnb': 2,\n",
+    "                'memory_fact': 1,\n",
+    "                'n_chunks': 10,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                }\n",
+    "\n",
+    "#Neurofinder 04.00.test \n",
+    "params_movie = {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_04_00_test/Yr_d1_512_d2_512_d3_1_order_C_frames_3000_.mmap',\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 0.8,  # merging threshold, max correlation allow\n",
+    "                'rf': 20,  # half-size of the patches in pixels. rf=25, patches are 50x50    20\n",
+    "                'stride_cnmf': 10,  # amounpl.it of overlap between the patches in pixels\n",
+    "                'K': 5,  # number of components per patch\n",
+    "                # if dendritic. In this case you need to set init_method to sparse_nmf\n",
+    "                'is_dendrites': False,\n",
+    "                'init_method': 'greedy_roi',\n",
+    "                'gSig': [5, 5],  # expected half size of neurons\n",
+    "                'alpha_snmf': None,  # this controls sparsity\n",
+    "                'final_frate': 10,\n",
+    "                'r_values_min_patch': .5,  # threshold on space consistency\n",
+    "                'fitness_min_patch': -10,  # threshold on time variability\n",
+    "                # threshold on time variability (if nonsparse activity)\n",
+    "                'fitness_delta_min_patch': -10,\n",
+    "                'Npeaks': 5,\n",
+    "                'r_values_min_full': .8,\n",
+    "                'fitness_min_full': - 40,\n",
+    "                'fitness_delta_min_full': - 40,\n",
+    "                'only_init_patch': True,\n",
+    "                'gnb': 2,\n",
+    "                'memory_fact': 1,\n",
+    "                'n_chunks': 10,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                }\n",
+    "\n",
+    "# neurofinder 02.00\n",
+    "params_movie = {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_00_00/Yr_d1_512_d2_512_d3_1_order_C_frames_2936_.mmap',\n",
+    "                'p': 1,  # order of the autoregressive system\n",
+    "                'merge_thresh': 0.8,  # merging threshold, max correlation allow\n",
+    "                'rf': 20,  # half-size of the patches in pixels. rf=25, patches are 50x50    20\n",
+    "                'stride_cnmf': 10,  # amounpl.it of overlap between the patches in pixels\n",
+    "                'K': 6,  # number of components per patch\n",
+    "                # if dendritic. In this case you need to set init_method to sparse_nmf\n",
+    "                'is_dendrites': False,\n",
+    "                'init_method': 'greedy_roi',\n",
+    "                'gSig': [5, 5],  # expected half size of neurons\n",
+    "                'alpha_snmf': None,  # this controls sparsity\n",
+    "                'final_frate': 10,\n",
+    "                'r_values_min_patch': .5,  # threshold on space consistency\n",
+    "                'fitness_min_patch': -10,  # threshold on time variability\n",
+    "                # threshold on time variability (if nonsparse activity)\n",
+    "                'fitness_delta_min_patch': -10,\n",
+    "                'Npeaks': 5,\n",
+    "                'r_values_min_full': .8,\n",
+    "                'fitness_min_full': - 40,\n",
+    "                'fitness_delta_min_full': - 40,\n",
+    "                'only_init_patch': True,\n",
+    "                'gnb': 2,\n",
+    "                'memory_fact': 1,\n",
+    "                'n_chunks': 10,\n",
+    "                # whether to update the background components in the spatial phase\n",
+    "                'update_background_components': True,\n",
+    "                'low_rank_background': True,  # whether to update the using a low rank approximation. In the False case all the nonzero elements of the background components are updated using hals\n",
+    "                #(to be used with one background per patch)\n",
+    "                'swap_dim': False,\n",
+    "                'crop_pix': 10\n",
+    "                }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Parameters for the Movie"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params_display = {\n",
+    "    'downsample_ratio': .2,\n",
+    "    'thr_plot': 0.8\n",
+    "}\n",
+    "\n",
+    "# @params fname name of the movie\n",
+    "fname_new = params_movie['fname']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run Analysis "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The local backend is an alias for the multiprocessing backend, and the alias may be removed in some future version of Caiman\n"
+     ]
+    }
+   ],
+   "source": [
+    "c, dview, n_processes = cm.cluster.setup_cluster(\n",
+    "    backend='local', n_processes=None, single_thread=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load MEMMAP File"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# fname_new='Yr_d1_501_d2_398_d3_1_order_F_frames_369_.mmap'\n",
+    "Yr, dims, T = cm.load_memmap(fname_new)\n",
+    "d1, d2 = dims\n",
+    "images = np.reshape(Yr.T, [T] + list(dims), order='F')\n",
+    "Y = np.reshape(Yr, dims + (T,), order='F')\n",
+    "m_images = cm.movie(images)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Correlation image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x33c8e4c50>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if m_images.shape[0] < 10000:\n",
+    "    Cn = m_images.local_correlations(\n",
+    "        swap_dim=params_movie['swap_dim'], frames_per_chunk=1500)\n",
+    "    Cn[np.isnan(Cn)] = 0\n",
+    "else:\n",
+    "    Cn = np.array(cm.load(('/'.join(fname_new.split('/') \n",
+    "                                    [:-3] + ['projections', 'correlation_image_better.tif'])))).squeeze()\n",
+    "plt.imshow(Cn, cmap='gray', vmax=.95)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<>:24: SyntaxWarning: \"is not\" with 'str' literal. Did you mean \"!=\"?\n",
+      "<>:24: SyntaxWarning: \"is not\" with 'str' literal. Did you mean \"!=\"?\n",
+      "/var/folders/2r/g94ddsvn0_gbc2zf01hj0zn00000gn/T/ipykernel_75234/246607138.py:24: SyntaxWarning: \"is not\" with 'str' literal. Did you mean \"!=\"?\n",
+      "  if params_movie['init_method'] is not 'sparse_nmf':\n"
+     ]
+    },
+    {
+     "ename": "TypeError",
+     "evalue": "unsupported operand type(s) for /: 'NoneType' and 'float'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRemoteTraceback\u001b[0m                           Traceback (most recent call last)",
+      "\u001b[0;31mRemoteTraceback\u001b[0m: \n\"\"\"\nTraceback (most recent call last):\n  File \"/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/multiprocessing/pool.py\", line 125, in worker\n    result = (True, func(*args, **kwds))\n                    ^^^^^^^^^^^^^^^^^^^\n  File \"/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/multiprocessing/pool.py\", line 48, in mapstar\n    return list(map(*args))\n           ^^^^^^^^^^^^^^^^\n  File \"/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/map_reduce.py\", line 112, in cnmf_patches\n    cnm = cnm.fit(images)\n          ^^^^^^^^^^^^^^^\n  File \"/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/cnmf.py\", line 486, in fit\n    self.initialize(Y)\n  File \"/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/cnmf.py\", line 955, in initialize\n    initialize_components(Y, sn=estim.sn, options_total=self.params.to_dict(),\n  File \"/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/initialization.py\", line 300, in initialize_components\n    alpha_snmf /= np.mean(img) # normalize alpha for sparse nmf\n    ^^^^^^^^^^^^^^^^^^^^^^^^^^\nTypeError: unsupported operand type(s) for /: 'NoneType' and 'float'\n\"\"\"",
+      "\nThe above exception was the direct cause of the following exception:\n",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[8], line 37\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[38;5;66;03m# TODO: todocument\u001b[39;00m\n\u001b[1;32m     31\u001b[0m \u001b[38;5;66;03m# TODO: warnings 3\u001b[39;00m\n\u001b[1;32m     32\u001b[0m cnm \u001b[38;5;241m=\u001b[39m cnmf\u001b[38;5;241m.\u001b[39mCNMF(n_processes\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, k\u001b[38;5;241m=\u001b[39mK, gSig\u001b[38;5;241m=\u001b[39mgSig, merge_thresh\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmerge_thresh\u001b[39m\u001b[38;5;124m'\u001b[39m], p\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mp\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[1;32m     33\u001b[0m                 dview\u001b[38;5;241m=\u001b[39mdview, rf\u001b[38;5;241m=\u001b[39mrf, stride\u001b[38;5;241m=\u001b[39mstride_cnmf, memory_fact\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,\n\u001b[1;32m     34\u001b[0m                 method_init\u001b[38;5;241m=\u001b[39minit_method, alpha_snmf\u001b[38;5;241m=\u001b[39malpha_snmf, only_init_patch\u001b[38;5;241m=\u001b[39mparams_movie[\n\u001b[1;32m     35\u001b[0m                     \u001b[38;5;124m'\u001b[39m\u001b[38;5;124monly_init_patch\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[1;32m     36\u001b[0m                 gnb\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgnb\u001b[39m\u001b[38;5;124m'\u001b[39m], method_deconvolution\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124moasis\u001b[39m\u001b[38;5;124m'\u001b[39m, border_pix\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcrop_pix\u001b[39m\u001b[38;5;124m'\u001b[39m], low_rank_background\u001b[38;5;241m=\u001b[39mparams_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlow_rank_background\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[0;32m---> 37\u001b[0m cnm \u001b[38;5;241m=\u001b[39m \u001b[43mcnm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimages\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     39\u001b[0m A_tot \u001b[38;5;241m=\u001b[39m cnm\u001b[38;5;241m.\u001b[39mA\n\u001b[1;32m     40\u001b[0m C_tot \u001b[38;5;241m=\u001b[39m cnm\u001b[38;5;241m.\u001b[39mC\n",
+      "File \u001b[0;32m/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/cnmf.py:580\u001b[0m, in \u001b[0;36mCNMF.fit\u001b[0;34m(self, images, indices)\u001b[0m\n\u001b[1;32m    575\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(images, np\u001b[38;5;241m.\u001b[39mmemmap):\n\u001b[1;32m    576\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\n\u001b[1;32m    577\u001b[0m         \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mYou need to provide a memory mapped file as input if you use patches!!\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m    579\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mA, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mC, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mYrA, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mb, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mf, \\\n\u001b[0;32m--> 580\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39msn, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39moptional_outputs \u001b[38;5;241m=\u001b[39m \u001b[43mrun_CNMF_patches\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    581\u001b[0m \u001b[43m        \u001b[49m\u001b[43mimages\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdims\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    582\u001b[0m \u001b[43m        \u001b[49m\u001b[43mdview\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdview\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemory_fact\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mpatch\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmemory_fact\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    583\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgnb\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43minit\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mnb\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mborder_pix\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mpatch\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mborder_pix\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    584\u001b[0m \u001b[43m        \u001b[49m\u001b[43mlow_rank_background\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mpatch\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mlow_rank_background\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    585\u001b[0m \u001b[43m        \u001b[49m\u001b[43mdel_duplicates\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mpatch\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdel_duplicates\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    586\u001b[0m \u001b[43m        \u001b[49m\u001b[43mindices\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mindices\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    588\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mbl, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mc1, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mg, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mestimates\u001b[38;5;241m.\u001b[39mneurons_sn \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    589\u001b[0m logger\u001b[38;5;241m.\u001b[39minfo(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmerging\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "File \u001b[0;32m/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/caiman/source_extraction/cnmf/map_reduce.py:231\u001b[0m, in \u001b[0;36mrun_CNMF_patches\u001b[0;34m(file_name, shape, params, gnb, dview, memory_fact, border_pix, low_rank_background, del_duplicates, indices)\u001b[0m\n\u001b[1;32m    229\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dview \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    230\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmultiprocessing\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mtype\u001b[39m(dview)):\n\u001b[0;32m--> 231\u001b[0m         file_res \u001b[38;5;241m=\u001b[39m \u001b[43mdview\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmap_async\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcnmf_patches\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs_in\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m4294967\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    232\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    233\u001b[0m         \u001b[38;5;28;01mtry\u001b[39;00m:\n",
+      "File \u001b[0;32m/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/multiprocessing/pool.py:774\u001b[0m, in \u001b[0;36mApplyResult.get\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    772\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_value\n\u001b[1;32m    773\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 774\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_value\n",
+      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'NoneType' and 'float'"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# %% some parameter settings\n",
+    "# order of the autoregressive fit to calcium imaging in general one (slow gcamps) or two (fast gcamps fast scanning)\n",
+    "p = params_movie['p']\n",
+    "# merging threshold, max correlation allowed\n",
+    "merge_thresh = params_movie['merge_thresh']\n",
+    "# half-size of the patches in pixels. rf=25, patches are 50x50\n",
+    "rf = params_movie['rf']\n",
+    "# amounpl.it of overlap between the patches in pixels\n",
+    "stride_cnmf = params_movie['stride_cnmf']\n",
+    "# number of components per patch\n",
+    "K = params_movie['K']\n",
+    "# if dendritic. In this case you need to set init_method to sparse_nmf\n",
+    "is_dendrites = params_movie['is_dendrites']\n",
+    "# iinit method can be greedy_roi for round shapes or sparse_nmf for denritic data\n",
+    "init_method = params_movie['init_method']\n",
+    "# expected half size of neurons\n",
+    "gSig = params_movie['gSig']\n",
+    "# this controls sparsity\n",
+    "alpha_snmf = params_movie['alpha_snmf']\n",
+    "# frame rate of movie (even considering eventual downsampling)\n",
+    "final_frate = params_movie['final_frate']\n",
+    "\n",
+    "if params_movie['is_dendrites'] == True:\n",
+    "    if params_movie['init_method'] is not 'sparse_nmf':\n",
+    "        raise Exception('dendritic requires sparse_nmf')\n",
+    "    if params_movie['alpha_snmf'] is None:\n",
+    "        raise Exception('need to set a value for alpha_snmf')\n",
+    "# %% Extract spatial and temporal components on patches\n",
+    "t1 = time.time()\n",
+    "# TODO: todocument\n",
+    "# TODO: warnings 3\n",
+    "cnm = cnmf.CNMF(n_processes=1, k=K, gSig=gSig, merge_thresh=params_movie['merge_thresh'], p=params_movie['p'],\n",
+    "                dview=dview, rf=rf, stride=stride_cnmf, memory_fact=1,\n",
+    "                method_init=init_method, alpha_snmf=alpha_snmf, only_init_patch=params_movie[\n",
+    "                    'only_init_patch'],\n",
+    "                gnb=params_movie['gnb'], method_deconvolution='oasis', border_pix=params_movie['crop_pix'], low_rank_background=params_movie['low_rank_background'])\n",
+    "cnm = cnm.fit(images)\n",
+    "\n",
+    "A_tot = cnm.A\n",
+    "C_tot = cnm.C\n",
+    "YrA_tot = cnm.YrA\n",
+    "b_tot = cnm.b\n",
+    "f_tot = cnm.f\n",
+    "sn_tot = cnm.sn\n",
+    "print(('Number of components:' + str(A_tot.shape[-1])))\n",
+    "# %%\n",
+    "pl.figure()\n",
+    "# TODO: show screenshot 12`\n",
+    "# TODO : change the way it is used\n",
+    "crd = plot_contours(A_tot, Cn, thr=params_display['thr_plot'])\n",
+    "\n",
+    "# DISCARD LOW QUALITY COMPONENT\n",
+    "final_frate = params_movie['final_frate']\n",
+    "# threshold on space consistency\n",
+    "r_values_min = params_movie['r_values_min_patch']\n",
+    "# threshold on time variability\n",
+    "fitness_min = params_movie['fitness_delta_min_patch']\n",
+    "# threshold on time variability (if nonsparse activity)\n",
+    "fitness_delta_min = params_movie['fitness_delta_min_patch']\n",
+    "Npeaks = params_movie['Npeaks']\n",
+    "traces = C_tot + YrA_tot\n",
+    "# TODO: todocument\n",
+    "idx_components, idx_components_bad = estimate_components_quality(\n",
+    "    traces, Y, A_tot, C_tot, b_tot, f_tot, final_frate=final_frate, Npeaks=Npeaks, r_values_min=r_values_min,\n",
+    "    fitness_min=fitness_min, fitness_delta_min=fitness_delta_min)\n",
+    "print(('Keeping ' + str(len(idx_components)) +\n",
+    "       ' and discarding  ' + str(len(idx_components_bad))))\n",
+    "# %%\n",
+    "# TODO: show screenshot 13\n",
+    "pl.figure()\n",
+    "crd = plot_contours(\n",
+    "    A_tot.tocsc()[:, idx_components], Cn, thr=params_display['thr_plot'])\n",
+    "# %%\n",
+    "A_tot = A_tot.tocsc()[:, idx_components]\n",
+    "C_tot = C_tot[idx_components]\n",
+    "# %% rerun updating the components to refine\n",
+    "t1 = time.time()\n",
+    "cnm = cnmf.CNMF(n_processes=1, k=A_tot.shape, gSig=gSig, merge_thresh=merge_thresh, p=p, dview=dview, Ain=A_tot,\n",
+    "                Cin=C_tot, b_in=b_tot,\n",
+    "                f_in=f_tot, rf=None, stride=None, method_deconvolution='oasis', gnb=params_movie['gnb'],\n",
+    "                low_rank_background=params_movie['low_rank_background'], update_background_components=params_movie['update_background_components'])\n",
+    "\n",
+    "cnm = cnm.fit(images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "'CNMF' object has no attribute 'A'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[9], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m A, C, b, f, YrA, sn \u001b[38;5;241m=\u001b[39m \u001b[43mcnm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m, cnm\u001b[38;5;241m.\u001b[39mC, cnm\u001b[38;5;241m.\u001b[39mb, cnm\u001b[38;5;241m.\u001b[39mf, cnm\u001b[38;5;241m.\u001b[39mYrA, cnm\u001b[38;5;241m.\u001b[39msn\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# %% again recheck quality of components, stricter criteria\u001b[39;00m\n\u001b[1;32m      3\u001b[0m final_frate \u001b[38;5;241m=\u001b[39m params_movie[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfinal_frate\u001b[39m\u001b[38;5;124m'\u001b[39m]\n",
+      "\u001b[0;31mAttributeError\u001b[0m: 'CNMF' object has no attribute 'A'"
+     ]
+    }
+   ],
+   "source": [
+    "A, C, b, f, YrA, sn = cnm.A, cnm.C, cnm.b, cnm.f, cnm.YrA, cnm.sn\n",
+    "# %% again recheck quality of components, stricter criteria\n",
+    "final_frate = params_movie['final_frate']\n",
+    "# threshold on space consistency\n",
+    "r_values_min = params_movie['r_values_min_full']\n",
+    "fitness_min = params_movie['fitness_min_full']  # threshold on time variability\n",
+    "# threshold on time variability (if nonsparse activity)\n",
+    "fitness_delta_min = params_movie['fitness_delta_min_full']\n",
+    "Npeaks = params_movie['Npeaks']\n",
+    "traces = C + YrA\n",
+    "idx_components, idx_components_bad, fitness_raw, fitness_delta, r_values = estimate_components_quality(\n",
+    "    traces, Y, A, C, b, f, final_frate=final_frate, Npeaks=Npeaks, r_values_min=r_values_min, fitness_min=fitness_min,\n",
+    "    fitness_delta_min=fitness_delta_min, return_all=True)\n",
+    "print(' ***** ')\n",
+    "print((len(traces)))\n",
+    "print((len(idx_components)))\n",
+    "# %% save results\n",
+    "np.savez(os.path.join(os.path.split(fname_new)[0], os.path.split(fname_new)[1][:-4] + 'results_analysis.npz'), Cn=Cn, fname_new=fname_new,\n",
+    "         A=A,\n",
+    "         C=C, b=b, f=f, YrA=YrA, sn=sn, d1=d1, d2=d2, idx_components=idx_components,\n",
+    "         idx_components_bad=idx_components_bad,\n",
+    "         fitness_raw=fitness_raw, fitness_delta=fitness_delta, r_values=r_values)\n",
+    "# we save it\n",
+    "# %%\n",
+    "# TODO: show screenshot 14\n",
+    "pl.subplot(1, 2, 1)\n",
+    "crd = plot_contours(A.tocsc()[:, idx_components],\n",
+    "                    Cn, thr=params_display['thr_plot'])\n",
+    "pl.subplot(1, 2, 2)\n",
+    "crd = plot_contours(A.tocsc()[:, idx_components_bad],\n",
+    "                    Cn, thr=params_display['thr_plot'])\n",
+    "# %%\n",
+    "# TODO: needinfo\n",
+    "view_patches_bar(Yr, scipy.sparse.coo_matrix(A.tocsc()[:, idx_components]), C[idx_components, :], b, f, dims[0], dims[1],\n",
+    "                 YrA=YrA[idx_components, :], img=Cn)\n",
+    "# %%\n",
+    "view_patches_bar(Yr, scipy.sparse.coo_matrix(A.tocsc()[:, idx_components_bad]), C[idx_components_bad, :], b, f, dims[0],\n",
+    "                 dims[1], YrA=YrA[idx_components_bad, :], img=Cn)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_00_00/Yr_d1_512_d2_512_d3_1_order_C_frames_2936_.results_analysis.npz'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[10], line 11\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;66;03m#analysis_file = '/mnt/ceph/neuro/jeremie_analysis/neurofinder.03.00.test/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_._results_analysis.npz'\u001b[39;00m\n\u001b[0;32m---> 11\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname_new\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname_new\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mresults_analysis.npz\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m ld:\n\u001b[1;32m     12\u001b[0m     \u001b[38;5;28mprint\u001b[39m(ld\u001b[38;5;241m.\u001b[39mkeys())\n\u001b[1;32m     13\u001b[0m     \u001b[38;5;28mlocals\u001b[39m()\u001b[38;5;241m.\u001b[39mupdate(ld)\n",
+      "File \u001b[0;32m/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/numpy/lib/npyio.py:427\u001b[0m, in \u001b[0;36mload\u001b[0;34m(file, mmap_mode, allow_pickle, fix_imports, encoding, max_header_size)\u001b[0m\n\u001b[1;32m    425\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m    426\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 427\u001b[0m     fid \u001b[38;5;241m=\u001b[39m stack\u001b[38;5;241m.\u001b[39menter_context(\u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mos_fspath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m    428\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m    430\u001b[0m \u001b[38;5;66;03m# Code to distinguish from NumPy binary files and pickles.\u001b[39;00m\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_00_00/Yr_d1_512_d2_512_d3_1_order_C_frames_2936_.results_analysis.npz'"
+     ]
+    }
+   ],
+   "source": [
+    "params_display = {\n",
+    "    'downsample_ratio': .2,\n",
+    "    'thr_plot': 0.8\n",
+    "}\n",
+    "\n",
+    "try:\n",
+    "    fname_new = fname_new[()]\n",
+    "except:\n",
+    "    pass\n",
+    "#analysis_file = '/mnt/ceph/neuro/jeremie_analysis/neurofinder.03.00.test/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_._results_analysis.npz'\n",
+    "with np.load(os.path.join(os.path.split(fname_new)[0], os.path.split(fname_new)[1][:-4] + 'results_analysis.npz')) as ld:\n",
+    "    print(ld.keys())\n",
+    "    locals().update(ld)\n",
+    "    dims_off = d1, d2\n",
+    "    A = scipy.sparse.coo_matrix(A[()])\n",
+    "    dims = (d1, d2)\n",
+    "    gSig = params_movie['gSig']\n",
+    "    fname_new = fname_new[()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'A' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[11], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m predictions, final_crops \u001b[38;5;241m=\u001b[39m evaluate_components_CNN(\n\u001b[0;32m----> 2\u001b[0m     \u001b[43mA\u001b[49m, dims, gSig, model_name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmodel/cnn_model\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      4\u001b[0m cm\u001b[38;5;241m.\u001b[39mmovie(final_crops)\u001b[38;5;241m.\u001b[39mplay(gain\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m, magnification\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m6\u001b[39m, fr\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m)\n\u001b[1;32m      5\u001b[0m cm\u001b[38;5;241m.\u001b[39mmovie(np\u001b[38;5;241m.\u001b[39msqueeze(final_crops[np\u001b[38;5;241m.\u001b[39mwhere(predictions[:, \u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m>\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.5\u001b[39m)[\u001b[38;5;241m0\u001b[39m]]))\u001b[38;5;241m.\u001b[39mplay(\n\u001b[1;32m      6\u001b[0m     gain\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2.\u001b[39m, magnification\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m, fr\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'A' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "predictions, final_crops = evaluate_components_CNN(\n",
+    "    A, dims, gSig, model_name='model/cnn_model')\n",
+    "\n",
+    "cm.movie(final_crops).play(gain=3, magnification=6, fr=5)\n",
+    "cm.movie(np.squeeze(final_crops[np.where(predictions[:, 1] >= 0.5)[0]])).play(\n",
+    "    gain=2., magnification=5, fr=5)\n",
+    "cm.movie(np.squeeze(final_crops[np.where(predictions[:, 0] >= 0.5)[0]])).play(\n",
+    "    gain=2., magnification=5, fr=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thresh = .5\n",
+    "idx_components_cnn = np.where(predictions[:, 1] >= thresh)[0]\n",
+    "idx_components_bad_cnn = np.where(predictions[:, 0] > (1 - thresh))[0]\n",
+    "\n",
+    "print(' ***** ')\n",
+    "print((len(final_crops)))\n",
+    "print((len(idx_components_cnn)))\n",
+    "\n",
+    "idx_components_r = np.where((r_values >= .5))[0]\n",
+    "idx_components_raw = np.where(fitness_raw < -5)[0]\n",
+    "idx_components_delta = np.where(fitness_delta < -5)[0]\n",
+    "#idx_and_condition_1 = np.where((r_values >= .65) & ((fitness_raw < -20) | (fitness_delta < -20)) )[0]\n",
+    "\n",
+    "idx_components = np.union1d(idx_components_r, idx_components_raw)\n",
+    "idx_components = np.union1d(idx_components, idx_components_delta)\n",
+    "idx_components_bad = np.setdiff1d(list(range(len(r_values))), idx_components)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(' ***** ')\n",
+    "print((len(r_values)))\n",
+    "print((len(idx_components)))\n",
+    "\n",
+    "plt.subplot(1, 2, 1)\n",
+    "crd = plot_contours(A.tocsc()[:, idx_components],\n",
+    "                    Cn, thr=params_display['thr_plot'], vmax=0.35)\n",
+    "plt.subplot(1, 2, 2)\n",
+    "crd = plot_contours(A.tocsc()[:, idx_components_bad],\n",
+    "                    Cn, thr=params_display['thr_plot'], vmax=0.35)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run Analysis "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c, dview, n_processes = cm.cluster.setup_cluster(\n",
+    "    backend='local', n_processes=None, single_thread=False)\n",
+    "\n",
+    "gt_file = os.path.join(os.path.split(fname_new)[0], os.path.split(\n",
+    "    fname_new)[1][:-4] + 'match_masks.npz')\n",
+    "\n",
+    "with np.load(gt_file) as ld:\n",
+    "    print(ld.keys())\n",
+    "    locals().update(ld)\n",
+    "    A_gt = scipy.sparse.coo_matrix(A_gt[()])\n",
+    "    dims = (d1, d2)\n",
+    "\n",
+    "view_patches_bar(Yr, scipy.sparse.coo_matrix(A_gt.toarray()[\n",
+    "                 :, idx_components_gt]), C_gt[idx_components_gt], b, f, dims[0], dims[1], YrA=YrA_gt[idx_components_gt], img=Cn)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dist_A = (normalize(A_gt.tocsc()[:, idx_components_gt], axis=0).T.dot(\n",
+    "    normalize(A.tocsc()[:, :], axis=0))).toarray()\n",
+    "dist_C = normalize(C_gt[idx_components_gt], axis=1).dot(\n",
+    "    normalize(C[:], axis=1).T)\n",
+    "dist_A = dist_A * (dist_A > 0)\n",
+    "\n",
+    "plt.figure(figsize=(30, 20))\n",
+    "tp_gt, tp_comp, fn_gt, fp_comp, performance_cons_off = cm.base.rois.nf_match_neurons_in_binary_masks(A_gt.toarray()[:, idx_components_gt].reshape([dims[0], dims[1], -1], order='F').transpose([2, 0, 1]),\n",
+    "                                                                                                     A.toarray()[:, :].reshape([dims[0], dims[1], -1], order='F').transpose([2, 0, 1]), thresh_cost=.7, min_dist=10,\n",
+    "                                                                                                     print_assignment=False, plot_results=True, Cn=Cn, labels=['GT', 'Offline'], D=[1 - dist_A * (dist_C > .8)])\n",
+    "plt.rcParams['pdf.fonttype'] = 42\n",
+    "font = {'family': 'Myriad Pro',\n",
+    "        'weight': 'regular',\n",
+    "        'size': 20}\n",
+    "plt.rc('font', **font)\n",
+    "\n",
+    "idx_final = tp_comp[np.where(dist_A[tp_gt, tp_comp] > 0.7)[0]]\n",
+    "view_patches_bar(Yr, scipy.sparse.coo_matrix(A.toarray()[\n",
+    "                 :, idx_final]), C[idx_final], b, f, dims[0], dims[1], YrA=YrA[idx_final], img=Cn)\n",
+    "\n",
+    "view_patches_bar(Yr, scipy.sparse.coo_matrix(A.toarray()[\n",
+    "                 :, fp_comp]), C[fp_comp], b, f, dims[0], dims[1], YrA=YrA[fp_comp], img=Cn)\n",
+    "\n",
+    "view_patches_bar(Yr, scipy.sparse.coo_matrix(A_gt.toarray()[\n",
+    "                 :, fn_gt]), C_gt[fn_gt], b_gt, f_gt, dims[0], dims[1], YrA=YrA_gt[fn_gt], img=Cn)\n",
+    "\n",
+    "plt.hist(r_values[tp_comp], 30)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.savez(os.path.join(os.path.split(fname_new)[0], os.path.split(fname_new)[1][:-4] + '_training_set.npz'), fname_new=fname_new,\n",
+    "         A_seeded=A_gt.tocsc()[\n",
+    "    :, idx_components_gt], C_seeded=C_gt[idx_components_gt], YrA_seeded=YrA_gt[idx_components_gt],\n",
+    "    A_matched=A.tocsc()[\n",
+    "    :, idx_final], C_matched=C[idx_final], YrA_matched=YrA[idx_final],\n",
+    "    A_unmatched=A_gt.tocsc()[\n",
+    "    :, fn_gt], C_unmatched=C_gt[fn_gt], YrA_unmatched=YrA_gt[fn_gt],\n",
+    "    A_negative=A.tocsc()[\n",
+    "    :, fp_comp], C_negative=C[fp_comp], YrA_negative=YrA[fp_comp],\n",
+    "    r_values=r_values, fitness_delta=fitness_delta, fitness_raw=fitness_raw, Cn=Cn, dims=dims\n",
+    ")\n",
+    "\n",
+    "with np.load(os.path.join(os.path.split(fname_new)[0], os.path.split(fname_new)[1][:-4] + '_training_set.npz')) as ld:\n",
+    "    print(ld.keys())\n",
+    "    locals().update(ld)\n",
+    "    fname_new = fname_new[()]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plots"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "thr = 0.98\n",
+    "pl.subplot(1, 3, 1)\n",
+    "crd = plot_contours(A_matched[()], Cn, thr=thr)\n",
+    "pl.subplot(1, 3, 2)\n",
+    "crd = plot_contours(A_unmatched[()], Cn, thr=thr)\n",
+    "pl.subplot(1, 3, 3)\n",
+    "crd = plot_contours(A_negative[()], Cn, thr=thr)\n",
+    "\n",
+    "plt.subplot(1, 3, 1)\n",
+    "crd = pl.imshow(A_matched[()].sum(1).reshape(\n",
+    "    dims, order='F'), vmax=A_matched[()].max() * .2)\n",
+    "plt.subplot(1, 3, 2)\n",
+    "crd = pl.imshow(A_unmatched[()].sum(1).reshape(\n",
+    "    dims, order='F'), vmax=A_unmatched[()].max() * .2)\n",
+    "plt.subplot(1, 3, 3)\n",
+    "crd = pl.imshow(A_negative[()].sum(1).reshape(\n",
+    "    dims, order='F'), vmax=A_negative[()].max() * .2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Maskings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masks_sue = scipy.io.loadmat('/mnt/xfs1/home/agiovann/Downloads/yuste_sue_masks.mat')\n",
+    "\n",
+    "with h5py.File('/mnt/xfs1/home/agiovann/Downloads/yuste_1.protoroi.mat')as f:\n",
+    "    print(f.keys())\n",
+    "    print(list(f['repository']))\n",
+    "    proto = f['prototypes']\n",
+    "    print(list(proto['params']))\n",
+    "    print(proto.keys())\n",
+    "    spatial = proto['spatial']\n",
+    "    print(spatial.keys())\n",
+    "    locals().update((dict(spatial.attrs.iteritems())))\n",
+    "    locals().update({k: np.array(l) for k, l in spatial.iteritems()})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "caiman_pytorch_2",
+   "language": "python",
+   "name": "caiman_pytorch_2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/caiman/train/prepare_training_set.ipynb b/caiman/train/prepare_training_set.ipynb
new file mode 100644
index 000000000..ed0bed3e8
--- /dev/null
+++ b/caiman/train/prepare_training_set.ipynb
@@ -0,0 +1,408 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import itertools\n",
+    "import numpy as np\n",
+    "import os\n",
+    "from sklearn.preprocessing import normalize\n",
+    "\n",
+    "import caiman as cm\n",
+    "from caiman.utils.utils import download_demo\n",
+    "from caiman.base.rois import com, extract_binary_masks_blob\n",
+    "from caiman.utils.visualization import plot_contours, view_patches_bar\n",
+    "from caiman.source_extraction.cnmf import cnmf as cnmf\n",
+    "from caiman.motion_correction import MotionCorrect, tile_and_correct, motion_correction_piecewise \n",
+    "from caiman.components_evaluation import estimate_components_quality, evaluate_components\n",
+    "from caiman.tests.comparison import comparison"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Loading up the Ground Truth Files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs = [{'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_03_00/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_.mmap', \n",
+    "              'gSig': [8, 8]},\n",
+    "          {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_04_00_test/Yr_d1_512_d2_512_d3_1_order_C_frames_3000_.mmap',\n",
+    "              'gSig': [5, 5]},\n",
+    "          {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_02_01/Yr_d1_512_d2_512_d3_1_order_C_frames_8000_.mmap',\n",
+    "              'gSig': [5, 5]},\n",
+    "          {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/yuste_single_150u/Yr_d1_200_d2_256_d3_1_order_C_frames_3000_.mmap',\n",
+    "              'gSig': [5, 5]},\n",
+    "          {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_00_00/Yr_d1_512_d2_512_d3_1_order_C_frames_2936_.mmap',\n",
+    "              'gSig': [6, 6]},\n",
+    "          {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_01_01/Yr_d1_512_d2_512_d3_1_order_C_frames_1825_.mmap',\n",
+    "              'gSig': [6, 6]},\n",
+    "          # {'fname': '/mnt/ceph/data/neuro/caiman/labeling/k53_20160530/images/final_map/Yr_d1_512_d2_512_d3_1_order_C_frames_116043_.mmap',\n",
+    "          #     'gSig': [6, 6]},\n",
+    "          # {'fname': '/mnt/ceph/data/neuro/caiman/labeling/J115_2015-12-09_L01_ELS/images/final_map/Yr_d1_463_d2_472_d3_1_order_C_frames_90000_.mmap',\n",
+    "          #    'gSig': [7, 7]},\n",
+    "          {'fname': '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/J123/Yr_d1_458_d2_477_d3_1_order_C_frames_41000_.mmap',\n",
+    "              'gSig': [12, 12]} ]\n",
+    "         # {'fname': '/mnt/ceph/data/neuro/caiman/labeling/Jan-AMG_exp3_001/images/final_map/Yr_d1_512_d2_512_d3_1_order_C_frames_115897_.mmap',\n",
+    "         #     'gSig': [7, 7]} ]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load Data and Analysis using match_masks.npz file "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_03_00/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_.mmap\n"
+     ]
+    },
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_03_00/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_.results_analysis.npz'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[5], line 9\u001b[0m\n\u001b[1;32m      5\u001b[0m gt_file \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39msplit(fname)[\u001b[38;5;241m0\u001b[39m], os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39msplit(fname)[\n\u001b[1;32m      6\u001b[0m                        \u001b[38;5;241m1\u001b[39m][:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m4\u001b[39m] \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmatch_masks.npz\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      8\u001b[0m \u001b[38;5;66;03m#analysis_file = '/mnt/ceph/neuro/jeremie_analysis/neurofinder.03.00.test/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_._results_analysis.npz'\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msplit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mresults_analysis.npz\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mlatin1\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m ld:\n\u001b[1;32m     10\u001b[0m     \u001b[38;5;28mprint\u001b[39m(ld\u001b[38;5;241m.\u001b[39mkeys())\n\u001b[1;32m     11\u001b[0m     \u001b[38;5;28mlocals\u001b[39m()\u001b[38;5;241m.\u001b[39mupdate(ld)\n",
+      "File \u001b[0;32m/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/numpy/lib/npyio.py:427\u001b[0m, in \u001b[0;36mload\u001b[0;34m(file, mmap_mode, allow_pickle, fix_imports, encoding, max_header_size)\u001b[0m\n\u001b[1;32m    425\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m    426\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 427\u001b[0m     fid \u001b[38;5;241m=\u001b[39m stack\u001b[38;5;241m.\u001b[39menter_context(\u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mos_fspath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m    428\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m    430\u001b[0m \u001b[38;5;66;03m# Code to distinguish from NumPy binary files and pickles.\u001b[39;00m\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/Users/manuelpaez/Documents/Flatiron/Caiman/data/source_components/neurofinder_03_00/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_.results_analysis.npz'"
+     ]
+    }
+   ],
+   "source": [
+    "for dc in inputs[:]:\n",
+    "    fname = dc['fname']\n",
+    "    print(fname)\n",
+    "    gSig = dc['gSig']\n",
+    "    gt_file = os.path.join(os.path.split(fname)[0], os.path.split(fname)[\n",
+    "                           1][:-4] + 'match_masks.npz')\n",
+    "    \n",
+    "    #analysis_file = '/mnt/ceph/neuro/jeremie_analysis/neurofinder.03.00.test/Yr_d1_498_d2_467_d3_1_order_C_frames_2250_._results_analysis.npz'\n",
+    "    with np.load(os.path.join(os.path.split(fname)[0], os.path.split(fname)[1][:-4] + 'results_analysis.npz'), encoding='latin1') as ld:\n",
+    "        print(ld.keys())\n",
+    "        locals().update(ld)\n",
+    "        dims_off = d1, d2\n",
+    "        A = scipy.sparse.coo_matrix(A[()])\n",
+    "        dims = (d1, d2)\n",
+    "\n",
+    "    gt_file = os.path.join(os.path.split(fname)[0], os.path.split(fname)[\n",
+    "                           1][:-4] + 'match_masks.npz')\n",
+    "    with np.load(gt_file, encoding='latin1') as ld:\n",
+    "        print(ld.keys())\n",
+    "        locals().update(ld)\n",
+    "        A_gt = scipy.sparse.coo_matrix(A_gt[()])\n",
+    "        dims = (d1, d2)\n",
+    "\n",
+    "    pl.figure()\n",
+    "    dist_A = (normalize(A_gt.tocsc()[:, idx_components_gt], axis=0).T.dot(\n",
+    "        normalize(A.tocsc()[:, :], axis=0))).toarray()\n",
+    "    dist_C = normalize(C_gt[idx_components_gt], axis=1).dot(\n",
+    "        normalize(C[:], axis=1).T)\n",
+    "    dist_A = dist_A * (dist_A > 0)\n",
+    "\n",
+    "    pl.figure(figsize=(30, 20))\n",
+    "    tp_gt, tp_comp, fn_gt, fp_comp, performance_cons_off = cm.base.rois.nf_match_neurons_in_binary_masks(A_gt.toarray()[:, idx_components_gt].reshape([dims[0], dims[1], -1], order='F').transpose([2, 0, 1]),\n",
+    "                                                                                                         A.toarray()[:, :].reshape([dims[0], dims[1], -1], order='F').transpose([2, 0, 1]), thresh_cost=.7, min_dist=10,\n",
+    "                                                                                                         print_assignment=False, plot_results=False, Cn=Cn, labels=['GT', 'Offline'], D=[1 - dist_A * (dist_C > .8)])\n",
+    "    pl.rcParams['pdf.fonttype'] = 42\n",
+    "    font = {'family': 'Myriad Pro',\n",
+    "            'weight': 'regular',\n",
+    "            'size': 20}\n",
+    "    pl.rc('font', **font)\n",
+    "    idx_final = tp_comp[np.where(dist_A[tp_gt, tp_comp] > 0.7)[0]]\n",
+    "    np.savez(os.path.join(os.path.split(fname)[0], os.path.split(fname)[1][:-4] + '_training_set_minions.npz'), fname_new=fname,\n",
+    "             A_seeded=A_gt.tocsc()[\n",
+    "        :, idx_components_gt], C_seeded=C_gt[idx_components_gt], YrA_seeded=YrA_gt[idx_components_gt],\n",
+    "        A_matched=A.tocsc()[\n",
+    "        :, idx_final], C_matched=C[idx_final], YrA_matched=YrA[idx_final],\n",
+    "        A_unmatched=A_gt.tocsc()[\n",
+    "        :, fn_gt], C_unmatched=C_gt[fn_gt], YrA_unmatched=YrA_gt[fn_gt],\n",
+    "        A_negative=A.tocsc()[\n",
+    "        :, fp_comp], C_negative=C[fp_comp], YrA_negative=YrA[fp_comp],\n",
+    "        r_values=r_values, fitness_delta=fitness_delta, fitness_raw=fitness_raw, Cn=Cn, dims=dims, gSig=gSig)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Obtain Training Files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "training_files = [os.path.join(dp, f) for dp, dn, filenames in os.walk('/mnt/ceph/data/neuro/caiman/') for f in filenames if 'set_minions.npz' in f]\n",
+    "print(training_files)\n",
+    "crop_size = 50\n",
+    "half_crop = crop_size // 2\n",
+    "id_file = 0\n",
+    "reference_gSig_neuron = 5\n",
+    "#folder = '/mnt/xfs1/home/agiovann/SOFTWARE/CaImAn/images_examples'\n",
+    "all_masks_gt = []\n",
+    "labels_gt = []\n",
+    "traces_gt = []"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Training Files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for fl in training_files:\n",
+    "\n",
+    "    with np.load(fl) as ld:\n",
+    "        print(ld.keys())\n",
+    "        locals().update(ld)\n",
+    "        zoom = reference_gSig_neuron / gSig[0]\n",
+    "        fname_new = fname_new[()]\n",
+    "        name_base = os.path.split(fname_new)[-1][:-5]\n",
+    "#        pl.figure()\n",
+    "#        pl.subplot(1, 3, 1)\n",
+    "#        pl.imshow(A_matched[()].sum(1).reshape(dims,order='F'), vmax = A_matched[()].max()*.2)\n",
+    "#        pl.subplot(1, 3, 2)\n",
+    "#        pl.imshow(A_unmatched[()].sum(1).reshape(dims,order='F'), vmax = A_unmatched[()].max()*.2)\n",
+    "#        pl.subplot(1, 3, 3)\n",
+    "#        pl.imshow(A_negative[()].sum(1).reshape(dims,order='F'), vmax = A_negative[()].max()*.2)\n",
+    "\n",
+    "#        coms = com(scipy.sparse.coo_matrix(A_matched[()]), dims[0], dims[1])\n",
+    "        if 'sparse' in str(type(A_matched[()])):\n",
+    "            A_matched = A_matched[()].toarray()\n",
+    "            A_unmatched = A_unmatched[()].toarray()\n",
+    "            A_negative = A_negative[()].toarray()\n",
+    "\n",
+    "        A_matched = normalize(A_matched, axis=0)\n",
+    "        A_unmatched = normalize(A_unmatched, axis=0)\n",
+    "        A_negative = normalize(A_negative, axis=0)\n",
+    "        \n",
+    "        masks_gt = np.concatenate([A_matched.reshape(tuple(dims) + (-1,), order='F').transpose([2, 0, 1]), A_unmatched.reshape(tuple(\n",
+    "            dims) + (-1,), order='F').transpose([2, 0, 1]), A_negative.reshape(tuple(dims) + (-1,), order='F').transpose([2, 0, 1])], axis=0)\n",
+    "        labels_gt = np.concatenate([labels_gt, np.ones(\n",
+    "            A_matched.shape[-1]), np.ones(A_unmatched.shape[-1]), np.zeros(A_negative.shape[-1])])\n",
+    "        traces_gt = traces_gt + list(YrA_matched + C_matched) + list(\n",
+    "            C_unmatched + YrA_unmatched) + list(C_negative + YrA_negative)\n",
+    "#        r_vals_gt = np.concatenate([r_vals_gt,])\n",
+    "#        raw_fitness_gt = np.concatenate([raw_fitness_gt,])\n",
+    "#        delta_fitness_gt = np.concatenate([delta_fitness_gt,])\n",
+    "\n",
+    "        coms = [scipy.ndimage.center_of_mass(mm) for mm in masks_gt]\n",
+    "        coms = np.maximum(coms, half_crop)\n",
+    "        coms = np.array([np.minimum(cm, dims - half_crop) for cm in coms])\n",
+    "\n",
+    "        count_neuro = 0\n",
+    "        for com, img in zip(coms, masks_gt):\n",
+    "            #            if zoom and zoom[counter]==1:\n",
+    "            #            if zoom>1:\n",
+    "            #\n",
+    "            #            elif zoom<1:\n",
+    "            com = com.astype(int)\n",
+    "            # Crop from x, y, w, h -> 100, 200, 300, 400\n",
+    "            crop_img = img[com[0] - half_crop:com[0] + half_crop,\n",
+    "                           com[1] - half_crop:com[1] + half_crop].copy()\n",
+    "#            crop_img = cv2.resize(crop_img,dsize=None,fx=zoom[id_file],fy=zoom[id_file])\n",
+    "#            newshape = np.array(crop_img.shape)//2\n",
+    "#            crop_img = crop_img[newshape[0]-half_crop:newshape[0]+half_crop,newshape[0]-half_crop:newshape[0]+half_crop]\n",
+    "\n",
+    "            borders = np.array(crop_img.shape)\n",
+    "            img_tmp = np.zeros_like(crop_img)\n",
+    "            crop_img = cv2.resize(crop_img, dsize=None, fx=zoom, fy=zoom)\n",
+    "            \n",
+    "            deltaw = (half_crop * 2 - crop_img.shape[0]) // 2\n",
+    "            deltah = (half_crop * 2 - crop_img.shape[1]) // 2\n",
+    "            img_tmp[deltaw:deltaw + crop_img.shape[0],\n",
+    "                    deltah:deltah + crop_img.shape[1]] = crop_img\n",
+    "            crop_img = img_tmp\n",
+    "            crop_img = crop_img / np.linalg.norm(crop_img)\n",
+    "            all_masks_gt.append(crop_img[np.newaxis, :, :, np.newaxis])\n",
+    "            augment_test = False\n",
+    "            cv2.imshow(\"cropped\", cv2.resize(crop_img, (480, 480)) * 10)\n",
+    "            cv2.waitKey(1)\n",
+    "            if augment_test:\n",
+    "                datagen = ImageDataGenerator(\n",
+    "                    #            featurewise_center=True,\n",
+    "                    #            featurewise_std_normalization=True,\n",
+    "                    shear_range=0.3,\n",
+    "                    rotation_range=360,\n",
+    "                    width_shift_range=0.2,\n",
+    "                    height_shift_range=0.2,\n",
+    "                    zoom_range=[.5, 2],\n",
+    "                    horizontal_flip=True,\n",
+    "                    vertical_flip=True,\n",
+    "                    random_mult_range=[.25, 2]\n",
+    "                )\n",
+    "                \n",
+    "                count_neuro += 1\n",
+    "                for x_batch, y_batch in datagen.flow(np.repeat(crop_img[np.newaxis, :, :], 10, 0)[:, :, :, None], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0], batch_size=10):\n",
+    "                    print(y_batch)\n",
+    "                    for b_img in x_batch:\n",
+    "                        cv2.imshow(\"cropped\", cv2.resize(\n",
+    "                            b_img.squeeze(), (480, 480)) * 10)\n",
+    "                        cv2.waitKey(300)\n",
+    "                        count_neuro += 1\n",
+    "                        print(count_neuro)\n",
+    "                    break\n",
+    "\n",
+    "\n",
+    "#            crop_img = cv2.resize(crop_img,dsize=None,fx=2,fy=2)\n",
+    "#            newshape = np.array(crop_img.shape)//2\n",
+    "#            crop_img = crop_img[newshape[0]-half_crop:newshape[0]+half_crop,newshape[0]-half_crop:newshape[0]+half_crop]\n",
+    "            # NOTE: its img[y: y + h, x: x + w] and *not* img[x: x + w, y: y + h]\n",
+    "\n",
+    "        id_file += 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_masks_gt = np.vstack(all_masks_gt)\n",
+    "cm.movie(np.squeeze(all_masks_gt[labels_gt == 0])).play(\n",
+    "    gain=3., magnification=10)\n",
+    "np.savez('ground_truth_components_minions.npz',\n",
+    "         all_masks_gt=all_masks_gt, labels_gt=labels_gt, traces_gt=traces_gt)\n",
+    "\n",
+    "def grouper(n, iterable, fillvalue=None):\n",
+    "    \"grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx\"\n",
+    "    args = [iter(iterable)] * n\n",
+    "    return itertools.zip_longest(*args, fillvalue=fillvalue)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Curate Once More. Remove Wrong Negatives"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "negatives = np.where(labels_gt == 1)[0]\n",
+    "wrong = []\n",
+    "count = 0\n",
+    "for a in grouper(50, negatives):\n",
+    "    print(np.max(a))\n",
+    "    print(count)\n",
+    "    a = np.array(a)[np.array(a) > 0].astype(int)\n",
+    "    count += 1\n",
+    "    img_mont_ = all_masks_gt[np.array(a)].squeeze()\n",
+    "    shps_img = img_mont_.shape\n",
+    "    img_mont = montage2d(img_mont_)\n",
+    "    shps_img_mont = np.array(img_mont.shape) // 50\n",
+    "    pl.figure(figsize=(20, 30))\n",
+    "    pl.imshow(img_mont)\n",
+    "    inp = pl.ginput(n=0, timeout=-100000)\n",
+    "    imgs_to_exclude = []\n",
+    "    inp = np.ceil(np.array(inp) / 50).astype(int) - 1\n",
+    "    if len(inp) > 0:\n",
+    "\n",
+    "        imgs_to_exclude = img_mont_[np.ravel_multi_index(\n",
+    "            [inp[:, 1], inp[:, 0]], shps_img_mont)]\n",
+    "#        pl.imshow(montage2d(imgs_to_exclude))\n",
+    "        wrong.append(np.array(a)[np.ravel_multi_index(\n",
+    "            [inp[:, 1], inp[:, 0]], shps_img_mont)])\n",
+    "    np.save('temp_label_pos_minions.npy', wrong)\n",
+    "    plt.close()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plot Masks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.imshow(montage2d(all_masks_gt[np.concatenate(wrong)].squeeze()))\n",
+    "\n",
+    "lab_pos_wrong = np.load('temp_label_pos_minions.npy')\n",
+    "lab_neg_wrong = np.load('temp_label_neg_plus_minions.npy')\n",
+    "\n",
+    "labels_gt_cur = labels_gt.copy()\n",
+    "labels_gt_cur[np.concatenate(lab_pos_wrong)] = 0\n",
+    "labels_gt_cur[np.concatenate(lab_neg_wrong)] = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Save the file to train the network"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.savez('ground_truth_comoponents_curated_minions.npz',\n",
+    "         all_masks_gt=all_masks_gt, labels_gt_cur=labels_gt_cur)\n",
+    "\n",
+    "plt.imshow(montage2d(all_masks_gt[labels_gt_cur == 0].squeeze()))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "caiman_pytorch_2",
+   "language": "python",
+   "name": "caiman_pytorch_2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/caiman/train/train_cnn_model_keras.ipynb b/caiman/train/train_cnn_model_keras.ipynb
new file mode 100644
index 000000000..ac882fe29
--- /dev/null
+++ b/caiman/train/train_cnn_model_keras.ipynb
@@ -0,0 +1,500 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Training the CNN Model for the 2D Spatial Components (Keras Version)\n",
+    "\n",
+    "This notebook will help to demonstrate how to train the CNN Model used in CaImAn to evaluate the shape of (2p) spatial components using the Keras API.\n",
+    "\n",
+    "The basic function for this is caiman.train.train_cnn_model_keras.keras_cnn_model(). It takes it the number of classes to build of a  CNN model (based on a tutorial on the CIFAR dataset). The other functions, caiman.train.train_cnn_model.data_generation(), takes as input the model, the training and validation datasets, and the parameters for the model to train the model. caiman.train.train_cnn_model_keras.save_model() and caiman.train.train_cnn_model_keras.load_model() save and retrieve the model and weights of the model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-08-06 20:34:40.739703: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
+      "2024-08-06 20:34:40.770178: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import os\n",
+    "import keras \n",
+    "from keras.layers import Input, Conv2D, Activation, MaxPooling2D, Dropout, Flatten, Dense \n",
+    "from keras.models import save_model, load_model \n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.utils import class_weight as cw\n",
+    "\n",
+    "import caiman as cm\n",
+    "from caiman.paths import caiman_datadir\n",
+    "from caiman.train.train_cnn_model_helper import cnn_model_keras, save_model_keras, load_model_keras\n",
+    "\n",
+    "os.environ[\"KERAS_BACKEND\"] = \"torch\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initalizing the Parameters for the Model "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 128\n",
+    "num_classes = 2\n",
+    "epochs = 1000 #Can be upgraded to 5000\n",
+    "test_fraction = 0.25\n",
+    "augmentation = False \n",
+    "img_rows, img_cols = 50, 50 #input image dimensions\n",
+    "\n",
+    "#Note: Augmentation is currently not working "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading the Dataset of the Model "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with np.load('/mnt/ceph/data/neuro/caiman/data_minions/ground_truth_components_curated_minions.npz') as ld:\n",
+    "    all_masks_gt = ld['all_masks_gt']\n",
+    "    labels_gt = ld['labels_gt_cur']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Constructing the Training and Validation Set for the Model "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "x_train shape: (6771, 50, 50, 1)\n",
+      "6771 train samples\n",
+      "2257 test samples\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_train, x_test, y_train, y_test = train_test_split(\n",
+    "all_masks_gt, labels_gt, test_size=test_fraction)\n",
+    "\n",
+    "# class_weight = cw.compute_class_weight(class_weight='balanced', classes=np.unique(y_train), y=y_train)\n",
+    "\n",
+    "if keras.config.image_data_format() == 'channels_first':\n",
+    "    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\n",
+    "    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\n",
+    "    input_shape = (1, img_rows, img_cols)\n",
+    "else:\n",
+    "    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\n",
+    "    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n",
+    "    input_shape = (img_rows, img_cols, 1)\n",
+    "    \n",
+    "x_train = x_train.astype('float32')\n",
+    "x_test = x_test.astype('float32')\n",
+    "print('x_train shape:', x_train.shape)\n",
+    "print(x_train.shape[0], 'train samples')\n",
+    "print(x_test.shape[0], 'test samples')\n",
+    "\n",
+    "# convert class vectors to binary class matrices\n",
+    "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
+    "y_test = keras.utils.to_categorical(y_test, num_classes)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build and Evaluate the Model "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m27s\u001b[0m 481ms/step - accuracy: 0.5579 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 2/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 460ms/step - accuracy: 0.5808 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 3/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 460ms/step - accuracy: 0.5753 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 4/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 467ms/step - accuracy: 0.5778 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 5/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 505ms/step - accuracy: 0.5852 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 6/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m39s\u001b[0m 468ms/step - accuracy: 0.5814 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 7/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 478ms/step - accuracy: 0.5762 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 8/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 470ms/step - accuracy: 0.5771 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 9/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 459ms/step - accuracy: 0.5719 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 10/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 463ms/step - accuracy: 0.5788 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 11/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 476ms/step - accuracy: 0.5736 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 12/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 466ms/step - accuracy: 0.5809 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 13/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 473ms/step - accuracy: 0.5676 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 14/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 465ms/step - accuracy: 0.5848 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 15/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 470ms/step - accuracy: 0.5714 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 16/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 467ms/step - accuracy: 0.5723 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 17/1000\n",
+      "\u001b[1m53/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 469ms/step - accuracy: 0.5959 - loss: nan - val_accuracy: 0.5950 - val_loss: nan\n",
+      "Epoch 18/1000\n",
+      "\u001b[1m42/53\u001b[0m \u001b[32m━━━━━━━━━━━━━━━\u001b[0m\u001b[37m━━━━━\u001b[0m \u001b[1m4s\u001b[0m 436ms/step - accuracy: 0.5689 - loss: nan"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[7], line 9\u001b[0m\n\u001b[1;32m      3\u001b[0m model\u001b[38;5;241m.\u001b[39mcompile(loss\u001b[38;5;241m=\u001b[39mkeras\u001b[38;5;241m.\u001b[39mlosses\u001b[38;5;241m.\u001b[39mcategorical_crossentropy,\n\u001b[1;32m      4\u001b[0m                         optimizer\u001b[38;5;241m=\u001b[39mkeras\u001b[38;5;241m.\u001b[39moptimizers\u001b[38;5;241m.\u001b[39mAdam(learning_rate\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.01\u001b[39m), \n\u001b[1;32m      5\u001b[0m                         metrics\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maccuracy\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m      7\u001b[0m \u001b[38;5;66;03m# cnn_model_cifar = data_generation(cnn_model_cifar, augmentation, x_train, x_test, y_train, y_test, batch_size, epochs, class_weight)  \u001b[39;00m\n\u001b[1;32m      8\u001b[0m \u001b[38;5;66;03m#Augmentation does not work!!!\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     10\u001b[0m \u001b[43m              \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     11\u001b[0m \u001b[43m              \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mepochs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     12\u001b[0m \u001b[43m              \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m     13\u001b[0m \u001b[43m              \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_test\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     15\u001b[0m score \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mevaluate(x_test, y_test, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m     16\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mTest loss:\u001b[39m\u001b[38;5;124m'\u001b[39m, score[\u001b[38;5;241m0\u001b[39m])\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/keras/src/utils/traceback_utils.py:117\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    115\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    116\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 117\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    118\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    119\u001b[0m     filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/keras/src/backend/tensorflow/trainer.py:318\u001b[0m, in \u001b[0;36mTensorFlowTrainer.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq)\u001b[0m\n\u001b[1;32m    316\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m step, iterator \u001b[38;5;129;01min\u001b[39;00m epoch_iterator\u001b[38;5;241m.\u001b[39menumerate_epoch():\n\u001b[1;32m    317\u001b[0m     callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m--> 318\u001b[0m     logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    319\u001b[0m     logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_pythonify_logs(logs)\n\u001b[1;32m    320\u001b[0m     callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_end(step, logs)\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    152\u001b[0m   filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:832\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    829\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    831\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 832\u001b[0m   result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    834\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m    835\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:877\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    874\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[1;32m    875\u001b[0m \u001b[38;5;66;03m# In this case we have not created variables on the first call. So we can\u001b[39;00m\n\u001b[1;32m    876\u001b[0m \u001b[38;5;66;03m# run the first trace but we should fail if variables are created.\u001b[39;00m\n\u001b[0;32m--> 877\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    878\u001b[0m \u001b[43m    \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_variable_creation_config\u001b[49m\n\u001b[1;32m    879\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    880\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_created_variables:\n\u001b[1;32m    881\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCreating variables on a non-first call to a function\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    882\u001b[0m                    \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m decorated with tf.function.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[0;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[1;32m    137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[0;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[1;32m    140\u001b[0m \u001b[43m    \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[1;32m    141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py:1323\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[1;32m   1319\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m   1320\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m   1321\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m   1322\u001b[0m   \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1323\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1324\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m   1325\u001b[0m     args,\n\u001b[1;32m   1326\u001b[0m     possible_gradient_type,\n\u001b[1;32m   1327\u001b[0m     executing_eagerly)\n\u001b[1;32m   1328\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m    214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m    215\u001b[0m \u001b[38;5;250m  \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 216\u001b[0m   flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    217\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m    249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[1;32m    250\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[0;32m--> 251\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    252\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    253\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    254\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    255\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    256\u001b[0m   \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    257\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[1;32m    258\u001b[0m         \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m    259\u001b[0m         \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[1;32m    260\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[1;32m    261\u001b[0m     )\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/eager/context.py:1486\u001b[0m, in \u001b[0;36mContext.call_function\u001b[0;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[1;32m   1484\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[1;32m   1485\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1486\u001b[0m   outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1487\u001b[0m \u001b[43m      \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1488\u001b[0m \u001b[43m      \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1489\u001b[0m \u001b[43m      \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1490\u001b[0m \u001b[43m      \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1491\u001b[0m \u001b[43m      \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1492\u001b[0m \u001b[43m  \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1493\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   1494\u001b[0m   outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m   1495\u001b[0m       name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m   1496\u001b[0m       num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1500\u001b[0m       cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[1;32m   1501\u001b[0m   )\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/tensorflow/python/eager/execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m     52\u001b[0m   ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 53\u001b[0m   tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     54\u001b[0m \u001b[43m                                      \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     55\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m     56\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "model = cnn_model_keras(input_shape, num_classes)\n",
+    "\n",
+    "model.compile(loss=keras.losses.categorical_crossentropy,\n",
+    "                    optimizer=keras.optimizers.Adam(learning_rate=0.01), \n",
+    "                    metrics=['accuracy'])\n",
+    "    \n",
+    "# cnn_model_cifar = data_generation(cnn_model_cifar, augmentation, x_train, x_test, y_train, y_test, batch_size, epochs, class_weight)  \n",
+    "#Augmentation does not work!!!\n",
+    "model.fit(x_train, y_train,\n",
+    "              batch_size=batch_size,\n",
+    "              epochs=epochs,\n",
+    "              verbose=1,\n",
+    "              validation_data=(x_test, y_test))\n",
+    "\n",
+    "score = model.evaluate(x_test, y_test, verbose=0)\n",
+    "print('Test loss:', score[0])\n",
+    "print('Test accuracy:', score[1])\n",
+    "# Need to fix "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Save the Model and its weights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved trained model at /mnt/home/mpaez/caiman_data/model/cnn_model_test.keras \n"
+     ]
+    }
+   ],
+   "source": [
+    "save_model_path = save_model_keras(model, name='cnn_model_test')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m283/283\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 25ms/step\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/mnt/home/mpaez/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/numpy/lib/nanfunctions.py:1562: RuntimeWarning: Mean of empty slice\n",
+      "  return np.nanmean(a, axis, out=out, keepdims=keepdims)\n"
+     ]
+    }
+   ],
+   "source": [
+    "predictions = model.predict(all_masks_gt, batch_size=32, verbose=1)\n",
+    "cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 0] >= 0.5)[0]])).play(\n",
+    "    gain=3., magnification=5, fr=10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Retrieve the Model and its weights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Load trained model at /mnt/home/mpaez/caiman_data/model/cnn_model_test.keras \n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_1\"</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1mModel: \"sequential_1\"\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">48</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">48</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │           <span style=\"color: #00af00; text-decoration-color: #00af00\">320</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">46</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">46</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │         <span style=\"color: #00af00; text-decoration-color: #00af00\">9,248</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">23</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">23</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">23</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">23</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">23</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">23</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │        <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_7 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">21</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">21</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │        <span style=\"color: #00af00; text-decoration-color: #00af00\">36,928</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>)  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>)     │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">6400</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)            │     <span style=\"color: #00af00; text-decoration-color: #00af00\">3,277,312</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)            │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">2</span>)              │         <span style=\"color: #00af00; text-decoration-color: #00af00\">1,026</span> │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ conv2d_4 (\u001b[38;5;33mConv2D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m48\u001b[0m, \u001b[38;5;34m48\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │           \u001b[38;5;34m320\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_5 (\u001b[38;5;33mConv2D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m46\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │         \u001b[38;5;34m9,248\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_2 (\u001b[38;5;33mMaxPooling2D\u001b[0m)  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (\u001b[38;5;33mDropout\u001b[0m)             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m32\u001b[0m)     │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_6 (\u001b[38;5;33mConv2D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m23\u001b[0m, \u001b[38;5;34m64\u001b[0m)     │        \u001b[38;5;34m18,496\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv2d_7 (\u001b[38;5;33mConv2D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m64\u001b[0m)     │        \u001b[38;5;34m36,928\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling2d_3 (\u001b[38;5;33mMaxPooling2D\u001b[0m)  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m64\u001b[0m)     │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_4 (\u001b[38;5;33mDropout\u001b[0m)             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m64\u001b[0m)     │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten_1 (\u001b[38;5;33mFlatten\u001b[0m)             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6400\u001b[0m)           │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_2 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m)            │     \u001b[38;5;34m3,277,312\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_5 (\u001b[38;5;33mDropout\u001b[0m)             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m)            │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_3 (\u001b[38;5;33mDense\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2\u001b[0m)              │         \u001b[38;5;34m1,026\u001b[0m │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">10,029,992</span> (38.26 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m10,029,992\u001b[0m (38.26 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">3,343,330</span> (12.75 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m3,343,330\u001b[0m (12.75 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Optimizer params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">6,686,662</span> (25.51 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Optimizer params: \u001b[0m\u001b[38;5;34m6,686,662\u001b[0m (25.51 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "loaded_model = load_model_keras(save_model_path)\n",
+    "loaded_model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize Results "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m283/283\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 25ms/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "predictions = loaded_model.predict(all_masks_gt, batch_size=32, verbose=1)\n",
+    "cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 0] >= 0.5)[0]])).play(\n",
+    "    gain=3., magnification=5, fr=10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "caiman_pytorch",
+   "language": "python",
+   "name": "caiman_pytorch"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/caiman/train/train_cnn_model_pytorch.ipynb b/caiman/train/train_cnn_model_pytorch.ipynb
new file mode 100644
index 000000000..b10f52cf1
--- /dev/null
+++ b/caiman/train/train_cnn_model_pytorch.ipynb
@@ -0,0 +1,371 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Training the CNN Model for the 2D Spatial Components (Pytorch Version)\n",
+    "\n",
+    "This notebook will help to demonstrate how to train the CNN Model used in CaImAn to evaluate the shape of (2p) spatial components using the Torch API.\n",
+    "\n",
+    "The basic function for this is caiman.train.train_cnn_model_keras.cnn_model_pytorch(). It takes in the number of classes to build a CNN model. \n",
+    "\n",
+    "The other functions, caiman.train.helper.save_model_file() and caiman.train.helper.load_model_file() save and retrieve the model and weights of the model. \n",
+    "\n",
+    "Author: agiovanni, Manuel Paez"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import os\n",
+    "import torch\n",
+    "from torch.optim import Adam\n",
+    "from torch.utils.data import Dataset, TensorDataset, DataLoader\n",
+    "import torchvision.transforms.v2 as transforms\n",
+    "\n",
+    "import caiman as cm\n",
+    "from caiman.paths import caiman_datadir\n",
+    "from caiman.train.helper import cnn_model_pytorch, get_batch_accuracy, load_model_pytorch, save_model_pytorch\n",
+    "from caiman.train.helper import train_test_split, train, validate \n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "torch.cuda.is_available()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initalizing the Parameters for the Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 128\n",
+    "num_classes = 2\n",
+    "epochs = 100\n",
+    "test_fraction = 0.25\n",
+    "augmentation = True #Fix this \n",
+    "img_rows, img_cols = 50, 50 # input image dimensions\n",
+    "in_channels = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading the Dataset of the Model \n",
+    "\n",
+    "Note: do not use minions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: '/mnt/ceph/data/neuro/caiman/data_minions/ground_truth_components_curated_minions.npz'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[3], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m/mnt/ceph/data/neuro/caiman/data_minions/ground_truth_components_curated_minions.npz\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m ld: \n\u001b[1;32m      2\u001b[0m     all_masks_gt \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mtensor(ld[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mall_masks_gt\u001b[39m\u001b[38;5;124m'\u001b[39m], dtype\u001b[38;5;241m=\u001b[39mtorch\u001b[38;5;241m.\u001b[39mfloat32)\n\u001b[1;32m      3\u001b[0m     labels_gt \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mtensor(ld[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabels_gt_cur\u001b[39m\u001b[38;5;124m'\u001b[39m], dtype\u001b[38;5;241m=\u001b[39mtorch\u001b[38;5;241m.\u001b[39mlong)\n",
+      "File \u001b[0;32m/opt/anaconda3/envs/caiman_pytorch_2/lib/python3.12/site-packages/numpy/lib/npyio.py:427\u001b[0m, in \u001b[0;36mload\u001b[0;34m(file, mmap_mode, allow_pickle, fix_imports, encoding, max_header_size)\u001b[0m\n\u001b[1;32m    425\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m    426\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 427\u001b[0m     fid \u001b[38;5;241m=\u001b[39m stack\u001b[38;5;241m.\u001b[39menter_context(\u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mos_fspath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mrb\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[1;32m    428\u001b[0m     own_fid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m    430\u001b[0m \u001b[38;5;66;03m# Code to distinguish from NumPy binary files and pickles.\u001b[39;00m\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/mnt/ceph/data/neuro/caiman/data_minions/ground_truth_components_curated_minions.npz'"
+     ]
+    }
+   ],
+   "source": [
+    "with np.load('/mnt/ceph/data/neuro/caiman/data_minions/ground_truth_components_curated_minions.npz') as ld: \n",
+    "    all_masks_gt = torch.tensor(ld['all_masks_gt'], dtype=torch.float32) #define\n",
+    "    labels_gt = torch.tensor(ld['labels_gt_cur'], dtype=torch.long)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Constructing the Training and Validation Set for the Model "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'all_masks_gt' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m all_masks_gt \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mreshape(\u001b[43mall_masks_gt\u001b[49m, (\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, in_channels, img_rows, img_cols))\n\u001b[1;32m      2\u001b[0m dataset \u001b[38;5;241m=\u001b[39m TensorDataset(all_masks_gt, labels_gt) \n\u001b[1;32m      4\u001b[0m train_dataset, test_dataset \u001b[38;5;241m=\u001b[39m train_test_split(dataset, test_fraction)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'all_masks_gt' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "all_masks_gt = torch.reshape(all_masks_gt, (-1, in_channels, img_rows, img_cols))\n",
+    "dataset = TensorDataset(all_masks_gt, labels_gt) \n",
+    "\n",
+    "train_dataset, test_dataset = train_test_split(dataset, test_fraction)\n",
+    "\n",
+    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
+    "train_N = len(train_loader.dataset)\n",
+    "valid_loader = DataLoader(test_dataset, batch_size=batch_size)\n",
+    "valid_N = len(valid_loader.dataset)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build and Evaluate the Model "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0\n",
+      "Train - Loss: 36.1255 Accuracy: 0.5869\n",
+      "Valid - Loss: 36.0095 Accuracy: 1.7607\n",
+      "Epoch: 1\n",
+      "Train - Loss: 35.9488 Accuracy: 0.5869\n",
+      "Valid - Loss: 35.9438 Accuracy: 1.7607\n",
+      "Epoch: 2\n",
+      "Train - Loss: 36.0044 Accuracy: 0.5869\n",
+      "Valid - Loss: 35.9368 Accuracy: 1.7607\n",
+      "Epoch: 3\n",
+      "Train - Loss: 35.9931 Accuracy: 0.5869\n",
+      "Valid - Loss: 35.9785 Accuracy: 1.7607\n",
+      "Epoch: 4\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[7], line 8\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(epochs):\n\u001b[1;32m      7\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mEpoch: \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;241m.\u001b[39mformat(epoch))\n\u001b[0;32m----> 8\u001b[0m     \u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloss_function\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_N\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maugment\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m      9\u001b[0m     validate(model, train_loader, loss_function, optimizer, valid_N, augment\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m)\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/caiman/train/train_cnn_model_pytorch.py:70\u001b[0m, in \u001b[0;36mtrain\u001b[0;34m(model, train_loader, loss_function, optimizer, train_N, augment)\u001b[0m\n\u001b[1;32m     68\u001b[0m model\u001b[38;5;241m.\u001b[39mtrain()\n\u001b[1;32m     69\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m x, y \u001b[38;5;129;01min\u001b[39;00m train_loader:\n\u001b[0;32m---> 70\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m  \n\u001b[1;32m     71\u001b[0m     optimizer\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m     72\u001b[0m     batch_loss \u001b[38;5;241m=\u001b[39m loss_function(output, y)\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/torch/nn/modules/module.py:1532\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1530\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1531\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1532\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/torch/nn/modules/module.py:1541\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1536\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1537\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1538\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1539\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1540\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1541\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1543\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1544\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/caiman/train/train_cnn_model_pytorch.py:26\u001b[0m, in \u001b[0;36mcnn_model_pytorch.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     25\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x):\n\u001b[0;32m---> 26\u001b[0m     x \u001b[38;5;241m=\u001b[39m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrelu\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconv1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     27\u001b[0m     x \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39mrelu(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconv2(x))\n\u001b[1;32m     28\u001b[0m     x \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39mdropout(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmaxpool2d1(x))\n",
+      "File \u001b[0;32m~/miniconda3/envs/caiman_pytorch/lib/python3.11/site-packages/torch/nn/functional.py:1500\u001b[0m, in \u001b[0;36mrelu\u001b[0;34m(input, inplace)\u001b[0m\n\u001b[1;32m   1498\u001b[0m     result \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mrelu_(\u001b[38;5;28minput\u001b[39m)\n\u001b[1;32m   1499\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1500\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrelu\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1501\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "model = cnn_model_pytorch(in_channels, num_classes)\n",
+    "\n",
+    "loss_function = torch.nn.CrossEntropyLoss()\n",
+    "optimizer = Adam(model.parameters())\n",
+    "\n",
+    "for epoch in range(epochs):\n",
+    "    print('Epoch: {}'.format(epoch))\n",
+    "    train(model, train_loader, loss_function, optimizer, train_N, augment=None)\n",
+    "    validate(model, train_loader, loss_function, optimizer, valid_N, augment=None)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Save the Model and its weights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "save_model_pytorch() missing 1 required positional argument: 'name'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m save_model_path \u001b[38;5;241m=\u001b[39m \u001b[43msave_model_pytorch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[0;31mTypeError\u001b[0m: save_model_pytorch() missing 1 required positional argument: 'name'"
+     ]
+    }
+   ],
+   "source": [
+    "save_model_path = save_model_pytorch(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize the Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([[0.7271, 0.2729],\n",
+      "        [0.7409, 0.2591],\n",
+      "        [0.7388, 0.2612],\n",
+      "        ...,\n",
+      "        [0.7291, 0.2709],\n",
+      "        [0.7180, 0.2820],\n",
+      "        [0.6821, 0.3179]])\n",
+      "torch tensor([[[0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         ...,\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.]],\n",
+      "\n",
+      "        [[0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         ...,\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.]],\n",
+      "\n",
+      "        [[0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         ...,\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.]],\n",
+      "\n",
+      "        ...,\n",
+      "\n",
+      "        [[0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         ...,\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.]],\n",
+      "\n",
+      "        [[0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         ...,\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.]],\n",
+      "\n",
+      "        [[0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         ...,\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.],\n",
+      "         [0., 0., 0.,  ..., 0., 0., 0.]]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# predictions = model.predict(all_masks_gt, batch_size=32, verbose=1) fix this \n",
+    "with torch.no_grad():\n",
+    "    predictions = model(all_masks_gt) \n",
+    "    \n",
+    "A = torch.squeeze(all_masks_gt[torch.where(predictions[:, 0] >= 0.5)[0]]).numpy()\n",
+    "cm.movie(A).play(gain=3., magnification=5, fr=10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Retrieve the Model and its weights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loaded_model = load_model_pytorch(save_model_path)\n",
+    "loaded_model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize Results "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predictions = loaded_model.predict(all_masks_gt, batch_size=32, verbose=1)\n",
+    "cm.movie(np.squeeze(all_masks_gt[np.where(predictions[:, 0] >= 0.5)[0]])).play(\n",
+    "    gain=3., magnification=5, fr=10)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "caiman_pytorch_2",
+   "language": "python",
+   "name": "caiman_pytorch_2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/caiman/train/training.md b/caiman/train/training.md
new file mode 100644
index 000000000..3b8db54d4
--- /dev/null
+++ b/caiman/train/training.md
@@ -0,0 +1,6 @@
+HOW TO GENERATE GROUND TRUTH DATA TO TRAIN THE NETWORK
+
+Step 1: Go to ground_truth_cnmf_seeded.py and generate new ground truth. This generates a file ending in match_masks.npz
+Step 2: Go to match_seeded_gt.py IF you want to match the cnmf-seeded components from GT with the results of a CNMF run
+Step 3: Go to prepare_training_set.py IF you want to clean up the components
+Step 4: Train the network from train_cnn_model_pytorch.ipynb
\ No newline at end of file
diff --git a/caiman/utils/nn_models.py b/caiman/utils/nn_models.py
index fd1a63fc5..1adc82904 100644
--- a/caiman/utils/nn_models.py
+++ b/caiman/utils/nn_models.py
@@ -5,22 +5,28 @@
 one photon data using a "ring-CNN" background model.
 """
 
-import numpy as np
+import keras 
+from keras import ops
+from keras.constraints import Constraint 
+from keras.layers import Input, Dense, Reshape, Layer, Activation
+from keras.models import Model
+from keras.optimizers import Adam
+from keras.callbacks import ModelCheckpoint, EarlyStopping, LearningRateScheduler
+from keras.initializers import Constant, RandomUniform
+from keras.utils import Sequence
+
 import os
-import tensorflow as tf
-from tensorflow.keras.layers import Input, Dense, Reshape, Layer, Activation
-from tensorflow.keras.models import Model
-from tensorflow.keras.optimizers import Adam
-from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping, LearningRateScheduler
-from tensorflow.keras import backend as K
-from tensorflow.keras.initializers import Constant, RandomUniform
-from tensorflow.keras.utils import Sequence
+os.environ["KERAS_BACKEND"] = "torch"
+import numpy as np
+
 import time
+import torch 
+import torch.nn.functional as F
+import torch.nn as nn
 
 import caiman.base.movies
 from caiman.paths import caiman_datadir
 
-
 class CalciumDataset(Sequence):
     def __init__(self, files, random_state=42, batch_size=32, train=True,
                  var_name_hdf5='mov', subindices=None):
@@ -94,12 +100,12 @@ class Masked_Conv2D(Layer):
             add a bias term to each convolution kernel
 
     Returns:
-        Masked_Conv2D: tensorflow.keras.layer
+        Masked_Conv2D: keras.layer
             A trainable layer implementing the convolution with a ring
     """
     def __init__(self, output_dim=1, kernel_size=(5,5), strides=(1,1),
                radius_min=2, radius_max=3, initializer='uniform',
-               use_bias=True): #, output_dim):
+               use_bias=True): 
         self.output_dim = output_dim
         self.kernel_size = kernel_size
         self.radius_min = radius_min
@@ -121,29 +127,23 @@ def __init__(self, output_dim=1, kernel_size=(5,5), strides=(1,1),
         super(Masked_Conv2D, self).__init__()
 
     def build(self, input_shape):
-        try:
-            n_filters = input_shape[-1].value   # tensorflow < 2
-        except:
-            n_filters = input_shape[-1]         # tensorflow >= 2
+        n_filters = input_shape[-1] 
         self.h = self.add_weight(name='h',
                                  shape= self.kernel_size + (n_filters, self.output_dim,),
                                  initializer=self.initializer,
-                                 constraint=masked_constraint(self.mask),
+                                 constraint=MaskedConstraint(self.mask), 
                                  trainable=True)
 
         self.b = self.add_weight(name='b',
                                  shape=(self.output_dim,),
                                  initializer=Constant(0),
-                                 trainable=self.use_bias)
+                                 trainable=self.use_bias) 
         super(Masked_Conv2D, self).build(input_shape)
 
     def call(self, x):
-        #hm = tf.multiply(self.h, K.expand_dims(K.expand_dims(tf.cast(self.mask, float))))
-        #hm = tf.multiply(hm, hm>0)
-        #hm = tf.where(hm>0, hm, 0)
-        y = K.conv2d(x, self.h, padding='same', strides=self.strides)
+        y = ops.conv(x, self.h, strides=self.strides, padding='same')
         if self.use_bias:
-            y = y + tf.expand_dims(self.b, axis=0)
+            y = y + torch.unsqueeze(self.b, dim=0)
         return y
 
     def compute_output_shape(self, input_shape):
@@ -178,28 +178,18 @@ def get_mask(gSig=5, r_factor=1.5, width=5):
     R[R>0] = 1
     return R
 
-def masked_constraint(R):
-    """ Enforces constraint for kernel to be non-negative everywhere and zero outside the ring
-
-    Args:
-        R: np.array
-            Binary mask that extracts 
-
-    Returns:
-        my_constraint: function
-            Function that enforces the constraint
-    """
-    R = tf.cast(R, dtype=tf.float32)
-    R_exp = tf.expand_dims(tf.expand_dims(R, -1), -1)
-    def my_constraint(x):
-        Rt = tf.tile(R_exp, [1, 1, 1, x.shape[-1]])
-        Z = tf.zeros_like(x)
-        return tf.where(Rt>0, x, Z)
-    return my_constraint
+class MaskedConstraint(keras.constraints.Constraint):
+    def __init__(self, R):
+        R = torch.tensor(R).float() 
+        self.R_exp = torch.unsqueeze(torch.unsqueeze(R, dim=-1), dim=-1)
 
+    def __call__(self, x):
+        Rt = torch.tile(self.R_exp, [1, 1, 1, x.shape[-1]])
+        Z = torch.zeros_like(x)
+        return torch.where(Rt > 0, x, Z)
 
 class Hadamard(Layer):
-    """ Creates a tensorflow.keras multiplicative layer that performs
+    """ Creates a keras multiplicative layer that performs
     pointwise multiplication with a set of learnable weights.
 
     Args:
@@ -217,8 +207,8 @@ def build(self, input_shape):
         super(Hadamard, self).build(input_shape)
 
     def call(self, x):
-        hm = tf.multiply(x, self.kernel)
-        sm = tf.reduce_sum(hm, axis=-1, keepdims=True)
+        hm = torch.multiply(x, self.kernel)
+        sm = torch.sum(hm, dim=-1, keepdim=True)
         return sm
 
     def compute_output_shape(self, input_shape):
@@ -226,7 +216,7 @@ def compute_output_shape(self, input_shape):
 
 
 class Additive(Layer):
-    """ Creates a tensorflow.keras additive layer that performs
+    """ Creates a keras additive layer that performs
     pointwise addition with a set of learnable weights.
 
     Args:
@@ -246,7 +236,7 @@ def build(self, input_shape):
         super(Additive, self).build(input_shape)
 
     def call(self, x):
-        hm = tf.add(x, self.kernel)
+        hm = torch.add(x, self.kernel)
         return hm
 
     def compute_output_shape(self, input_shape):
@@ -265,9 +255,9 @@ def cropped_loss(gSig=0):
     """
     def my_loss(y_true, y_pred):
         if gSig > 0:
-            error = tf.square(y_true[gSig:-gSig, gSig:-gSig] - y_pred[gSig:-gSig, gSig:-gSig])
+            error = torch.square(y_true[gSig:-gSig, gSig:-gSig] - y_pred[gSig:-gSig, gSig:-gSig])
         else:
-            error = tf.square(y_true - y_pred)
+            error = torch.square(y_true - y_pred) 
         return error
     return my_loss
 
@@ -284,7 +274,7 @@ def quantile_loss(qnt=.50):
     def my_qnt_loss(y_true, y_pred):
         error = y_true - y_pred
         pos_error = error > 0
-        return tf.where(pos_error, error*qnt, error*(qnt-1))
+        return torch.where(pos_error, error*qnt, error*(qnt-1))
     return my_qnt_loss
 
 def rate_scheduler(factor=0.5, epoch_length=200, samples_length=1e4):
@@ -300,12 +290,59 @@ def my_scheduler(epoch, lr):
         return rate
     return my_scheduler
 
+def total_variation(image):
+    """
+    Implements PyTorch version of the the anisotropic 2-D version of the formula described here:
+    https://en.wikipedia.org/wiki/Total_variation_denoising
+
+    Args:
+    images: 4-D Tensor of shape `[batch, height, width, channels]` or 3-D Tensor
+      of shape `[height, width, channels]`.
+    name: A name for the operation (optional).
+
+    Raises:
+        ValueError: if images.shape is not a 3-D or 4-D vector.
+
+    Returns:
+        The total variation of `images`.
+    """
+    ndim = image.ndim
+    if ndim == 3: 
+        # The input is a single image with shape [height, width, channels].
+
+        # Calculate the difference of neighboring pixel-values.
+        # The images are shifted one pixel along the height and width by slicing.
+        pixel_dif1 = images[1:, :, :] - images[:-1, :, :]
+        pixel_dif2 = images[:, 1:, :] - images[:, :-1, :]
+        sum_axis = None
+    elif ndims == 4:
+        # The input is a batch of images with shape:
+        # [batch, height, width, channels].
+
+        # Calculate the difference of neighboring pixel-values.
+        # The images are shifted one pixel along the height and width by slicing.
+        pixel_dif1 = images[:, 1:, :, :] - images[:, :-1, :, :]
+        pixel_dif2 = images[:, :, 1:, :] - images[:, :, :-1, :]
+
+        # Only sum for the last 3 axis.
+        # This results in a 1-D tensor with the total variation for each image.
+        sum_axis = [1, 2, 3]
+    else:
+      raise ValueError('\'images\' must be either 3 or 4-dimensional.')
+
+    # Calculate the total variation by taking the absolute value of the
+    # pixel-differences and summing over the appropriate axis.
+    tot_var = (torch.sum(torch.abs(pixel_dif1), axis=sum_axis) +
+        torch.sum(torch.abs(pixel_dif2), axis=sum_axis))
+
+    return tot_var 
+
 def total_variation_loss():
     """ Returns a total variation norm loss function that can be used for training.
     """
     def my_total_variation_loss(y_true, y_pred):
-        error = tf.reduce_mean(tf.image.total_variation(y_true - y_pred))
-        return error
+        error = torch.mean(total_variation(y_true - y_pred))
+        return error 
     return my_total_variation_loss
 
 def b0_initializer(Y, pct=10):
@@ -320,12 +357,12 @@ def b0_initializer(Y, pct=10):
     Returns:
         b0_init: keras initializer
     """
-    def b0_init(shape, dtype=tf.float32):
+    def b0_init(shape, dtype=torch.float32):
         mY = np.percentile(Y, pct, 0)
-        #mY = np.min(Y, axis=0)
+        mY = torch.from_numpy(mY)
         if mY.ndim == 2:
-            mY = tf.expand_dims(mY, -1)
-        mY = tf.cast(mY, dtype=tf.float32)
+            mY = torch.unsqueeze(mY, dim=-1)
+        mY = mY.float()
         return mY
     return b0_init
 
@@ -391,7 +428,7 @@ def create_LN_model(Y=None, shape=(None, None, 1), n_channels=2, gSig=5, r_facto
             add a bias term to each convolution kernel
 
     Returns:
-        model_LIN: tf.keras model compiled and ready to be trained.
+        model_LIN: keras model compiled and ready to be trained.
     """
     x_in = Input(shape=shape)
     radius_min = int(gSig*r_factor)
@@ -463,7 +500,7 @@ def create_NL_model(Y=None, shape=(None, None, 1), n_channels=8, gSig=5, r_facto
             add a bias term to each convolution kernel
 
     Returns:
-        model_LIN: tf.keras model compiled and ready to be trained.
+        model_LIN: keras model compiled and ready to be trained.
     """
     x_in = Input(shape=shape)
     radius_min = int(gSig*r_factor)
@@ -519,7 +556,7 @@ def fit_NL_model(model_NL, Y, patience=5, val_split=0.2, batch_size=32,
         Y = np.expand_dims(Y, axis=-1)
     run_logdir = get_run_logdir()
     os.mkdir(run_logdir)
-    path_to_model = os.path.join(run_logdir, 'model.h5')
+    path_to_model = os.path.join(run_logdir, 'model.weights.h5')
     chk = ModelCheckpoint(filepath=path_to_model,
                           verbose=0, save_best_only=True, save_weights_only=True)
     es = EarlyStopping(monitor='val_loss', patience=patience,
@@ -530,7 +567,7 @@ def fit_NL_model(model_NL, Y, patience=5, val_split=0.2, batch_size=32,
     history_NL = model_NL.fit(Y, Y, epochs=epochs, batch_size=batch_size,
                             shuffle=True, validation_split=val_split,
                             callbacks=callbacks)
-    model_NL.load_weights(os.path.join(run_logdir, 'model.h5'))
+    model_NL.load_weights(os.path.join(run_logdir, 'model.weights.h5'))
     return model_NL, history_NL, path_to_model
 
 def get_MCNN_model(Y, gSig=5, n_channels=8, lr=1e-4, pct=10, r_factor=1.5,
diff --git a/environment-minimal.yml b/environment-minimal.yml
index 81fa6898c..86106e708 100644
--- a/environment-minimal.yml
+++ b/environment-minimal.yml
@@ -9,6 +9,7 @@ dependencies:
 - ipython
 - ipyparallel
 - ipywidgets
+- keras
 - matplotlib
 - moviepy
 - pytest
@@ -22,7 +23,9 @@ dependencies:
 - scikit-image >=0.19.0
 - scikit-learn >=1.2
 - scipy >= 1.10.1
-- tensorflow >=2.4.0,<2.16
+# - tensorflow >=2.4.0,<2.16
 - tifffile
+- torch 
+- torchvision 
 - tqdm
 - zarr
diff --git a/environment.yml b/environment.yml
index 014c3532c..e7d4944fd 100644
--- a/environment.yml
+++ b/environment.yml
@@ -13,6 +13,7 @@ dependencies:
 - ipyparallel
 - jupyter
 - jupyter_bokeh
+- keras
 - matplotlib
 - moviepy
 - mypy
@@ -30,7 +31,7 @@ dependencies:
 - scikit-image >=0.19.0
 - scikit-learn >=1.2
 - scipy >= 1.10.1
-- tensorflow >=2.4.0,<2.16
+# - tensorflow >=2.4.0,<2.16
 - tifffile
 - tk
 - tqdm