lbm_suite2p_python 2.0.5__tar.gz → 2.2.0__tar.gz

lbm_suite2p_python-2.2.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: lbm_suite2p_python
+Version: 2.2.0
+Summary: Light Beads Microscopy Pipeline using Suite2p
+License-Expression: BSD-3-Clause
+Project-URL: homepage, https://github.com/MillerBrainObservatory/LBM-Suite2p-Python
+Keywords: Pipeline,Numpy,Microscopy,ScanImage,Suite2p,tiff
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: <3.12.10,>=3.12.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: mbo_utilities>=2.1.1
+Dynamic: license-file
+
+# LBM-Suite2p-Python
+
+> **Status:** Late-beta stage of development
+
+[![Documentation](https://img.shields.io/badge/Documentation-blue?style=for-the-badge&logo=readthedocs&logoColor=white)](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/index.html)
+
+[![PyPI - Version](https://img.shields.io/pypi/v/lbm-suite2p-python)](https://pypi.org/project/lbm-suite2p-python/)
+[![DOI](https://zenodo.org/badge/DOI/10.1007/978-3-319-76207-4_15.svg)](https://doi.org/10.1038/s41592-021-01239-8)
+
+A volumetric 2-photon calcium imaging processing pipeline for Light Beads Microscopy (LBM) datasets, built on Suite2p.
+
+A GUI is available via [mbo_utilities](https://millerbrainobservatory.github.io/mbo_utilities/index.html#gui) (GUI functionality will lag behind this pipeline).
+
+## Quick Start
+
+See the [installation documentation](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/install.html) for GUI dependencies and troubleshooting.
+
+```bash
+uv pip install lbm_suite2p_python
+```
+
+### Basic Usage
+
+```python
+import lbm_suite2p_python as lsp
+
+ops = {"two_step_registration": 1}
+files = [
+    r"D://demo//plane05_stitched.zarr",
+    r"D://demo//plane06_stitched.zarr",
+]
+
+# Process entire volume
+output_ops = lsp.run_volume(
+    input_files=files,
+    save_path=None,     # save next to tiffs
+    ops=ops,
+    keep_reg=True,      # Keep registered binaries
+    force_reg=False,    # Skip if already registered
+    force_detect=False  # Skip if stat.npy exists
+)
+```
+
+**Process a single plane:**
+```python
+ops_file = lsp.run_plane(
+    input_path=files[0],
+    save_path=None,
+    ops=ops,
+    keep_raw=False,  # Delete data_raw.bin after processing
+    keep_reg=True    # Keep data.bin (registered binary)
+)
+```
+
+## Documentation
+
+- **[Installation Guide](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/install.html)**
+- **[User Guide](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/user_guide.html)** - Complete usage examples
+- **[API Reference](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/api.html)**
+
+## Built With
+
+This pipeline integrates several open-source tools:
+
+- **[Suite2p](https://github.com/MouseLand/suite2p)** - Core registration and segmentation
+- **[Cellpose](https://github.com/MouseLand/cellpose)** - Anatomical segmentation (optional)
+- **[Rastermap](https://github.com/MouseLand/rastermap)** - Activity clustering (optional)
+- **[mbo_utilities](https://github.com/MillerBrainObservatory/mbo_utilities)** - ScanImage I/O and metadata
+- **[scanreader](https://github.com/atlab/scanreader)** - ScanImage metadata parsing
+
+## Issues & Support
+
+- **Bug reports:** [GitHub Issues](https://github.com/MillerBrainObservatory/LBM-Suite2p-Python/issues)
+- **Questions:** See [Suite2p documentation](https://suite2p.readthedocs.io/) for Suite2p-specific questions
+- **Known issues:** Widgets may throw "Invalid Rect" errors ([upstream issue](https://github.com/pygfx/wgpu-py/issues/716#issuecomment-2880853089))
+
+## Contributing
+
+Contributions are welcome! This project follows Suite2p's conventions and uses:
+- **Ruff** for linting and formatting (line length: 88, numpy docstring style)
+- **pytest** for testing
+- **Sphinx** for documentation

lbm_suite2p_python-2.2.0/README.md

@@ -0,0 +1,82 @@
+# LBM-Suite2p-Python
+
+> **Status:** Late-beta stage of development
+
+[![Documentation](https://img.shields.io/badge/Documentation-blue?style=for-the-badge&logo=readthedocs&logoColor=white)](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/index.html)
+
+[![PyPI - Version](https://img.shields.io/pypi/v/lbm-suite2p-python)](https://pypi.org/project/lbm-suite2p-python/)
+[![DOI](https://zenodo.org/badge/DOI/10.1007/978-3-319-76207-4_15.svg)](https://doi.org/10.1038/s41592-021-01239-8)
+
+A volumetric 2-photon calcium imaging processing pipeline for Light Beads Microscopy (LBM) datasets, built on Suite2p.
+
+A GUI is available via [mbo_utilities](https://millerbrainobservatory.github.io/mbo_utilities/index.html#gui) (GUI functionality will lag behind this pipeline).
+
+## Quick Start
+
+See the [installation documentation](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/install.html) for GUI dependencies and troubleshooting.
+
+```bash
+uv pip install lbm_suite2p_python
+```
+
+### Basic Usage
+
+```python
+import lbm_suite2p_python as lsp
+
+ops = {"two_step_registration": 1}
+files = [
+    r"D://demo//plane05_stitched.zarr",
+    r"D://demo//plane06_stitched.zarr",
+]
+
+# Process entire volume
+output_ops = lsp.run_volume(
+    input_files=files,
+    save_path=None,     # save next to tiffs
+    ops=ops,
+    keep_reg=True,      # Keep registered binaries
+    force_reg=False,    # Skip if already registered
+    force_detect=False  # Skip if stat.npy exists
+)
+```
+
+**Process a single plane:**
+```python
+ops_file = lsp.run_plane(
+    input_path=files[0],
+    save_path=None,
+    ops=ops,
+    keep_raw=False,  # Delete data_raw.bin after processing
+    keep_reg=True    # Keep data.bin (registered binary)
+)
+```
+
+## Documentation
+
+- **[Installation Guide](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/install.html)**
+- **[User Guide](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/user_guide.html)** - Complete usage examples
+- **[API Reference](https://millerbrainobservatory.github.io/LBM-Suite2p-Python/api.html)**
+
+## Built With
+
+This pipeline integrates several open-source tools:
+
+- **[Suite2p](https://github.com/MouseLand/suite2p)** - Core registration and segmentation
+- **[Cellpose](https://github.com/MouseLand/cellpose)** - Anatomical segmentation (optional)
+- **[Rastermap](https://github.com/MouseLand/rastermap)** - Activity clustering (optional)
+- **[mbo_utilities](https://github.com/MillerBrainObservatory/mbo_utilities)** - ScanImage I/O and metadata
+- **[scanreader](https://github.com/atlab/scanreader)** - ScanImage metadata parsing
+
+## Issues & Support
+
+- **Bug reports:** [GitHub Issues](https://github.com/MillerBrainObservatory/LBM-Suite2p-Python/issues)
+- **Questions:** See [Suite2p documentation](https://suite2p.readthedocs.io/) for Suite2p-specific questions
+- **Known issues:** Widgets may throw "Invalid Rect" errors ([upstream issue](https://github.com/pygfx/wgpu-py/issues/716#issuecomment-2880853089))
+
+## Contributing
+
+Contributions are welcome! This project follows Suite2p's conventions and uses:
+- **Ruff** for linting and formatting (line length: 88, numpy docstring style)
+- **pytest** for testing
+- **Sphinx** for documentation

{lbm_suite2p_python-2.0.5 → lbm_suite2p_python-2.2.0}/lbm_suite2p_python/__init__.py

@@ -5,6 +5,7 @@ from lbm_suite2p_python.run_lsp import *
 from lbm_suite2p_python.utils import *
 from lbm_suite2p_python.volume import *
 from lbm_suite2p_python.zplane import *
+from lbm_suite2p_python.postprocessing import *
 
 try:
     __version__ = version("lbm_suite2p_python")
@@ -15,6 +16,7 @@ except PackageNotFoundError:
 __all__ = [
     "run_volume",
     "run_plane",
+    "run_grid_search",
     "plot_traces",
     "plot_masks",
     "plot_rastermap",
@@ -24,6 +26,8 @@ __all__ = [
     "plot_execution_time",
     "plot_noise_distribution",
     "dff_rolling_percentile",
+    "dff_median_filter",
+    "dff_shot_noise",
     "load_ops",
     "load_planar_results",
     "default_ops",

lbm_suite2p_python-2.2.0/lbm_suite2p_python/default_ops.py

@@ -0,0 +1,214 @@
+"""MBO Default ops"""
+
+def s2p_ops():
+    """ default options to run pipeline """
+    return {
+        # file input/output settings
+        "look_one_level_down":
+            False,  # whether to look in all subfolders when searching for tiffs
+        "fast_disk": [],  # used to store temporary binary file, defaults to save_path0
+        "delete_bin": False,  # whether to delete binary file after processing
+        "mesoscan": False,  # for reading in scanimage mesoscope files
+        "bruker": False,  # whether or not single page BRUKER tiffs!
+        "bruker_bidirectional":
+            False,  # bidirectional multiplane in bruker: 0, 1, 2, 2, 1, 0 (True) vs 0, 1, 2, 0, 1, 2 (False)
+        "h5py": [],  # take h5py as input (deactivates data_path)
+        "h5py_key": "data",  # key in h5py where data array is stored
+        "nwb_file": "",  # take nwb file as input (deactivates data_path)
+        "nwb_driver": "",  # driver for nwb file (nothing if file is local)
+        "nwb_series":
+            "",  # TwoPhotonSeries name, defaults to first TwoPhotonSeries in nwb file
+        "save_path0": '',  # pathname where you'd like to store results, defaults to first item in data_path
+        "save_folder": [],  # directory you"d like suite2p results to be saved to
+        "subfolders": [
+        ],  # subfolders you"d like to search through when look_one_level_down is set to True
+        "move_bin":
+            False,  # if 1, and fast_disk is different than save_disk, binary file is moved to save_disk
+
+        # main settings
+        "nplanes": 1,  # each tiff has these many planes in sequence
+        "nchannels": 1,  # each tiff has these many channels per plane
+        "functional_chan":
+            1,  # this channel is used to extract functional ROIs (1-based)
+        "tau": 1.3,  # this is the main parameter for deconvolution
+        "fs":
+            10.,  # sampling rate (PER PLANE e.g. for 12 plane recordings it will be around 2.5)
+        "force_sktiff": False,  # whether or not to use scikit-image for tiff reading
+        "frames_include": -1,
+        "multiplane_parallel": False,  # whether or not to run on server
+        "ignore_flyback": [],
+
+        # output settings
+        "preclassify":
+            0.0,  # apply classifier before signal extraction with probability 0.3
+        "save_mat": False,  # whether to save output as matlab files
+        "save_NWB": False,  # whether to save output as NWB file
+        "combined":
+            True,  # combine multiple planes into a single result /single canvas for GUI
+        "aspect":
+            1.0,  # um/pixels in X / um/pixels in Y (for correct aspect ratio in GUI)
+
+        # bidirectional phase offset
+        "do_bidiphase":
+            False,  # whether or not to compute bidirectional phase offset (applies to 2P recordings only)
+        "bidiphase":
+            0,  # Bidirectional Phase offset from line scanning (set by user). Applied to all frames in recording.
+        "bidi_corrected":
+            False,  # Whether to do bidirectional correction during registration
+
+        # registration settings
+        "do_registration": True,  # whether to register data (2 forces re-registration)
+        "two_step_registration":
+            False,
+        # whether or not to run registration twice (useful for low SNR data). Set keep_movie_raw to True if setting this parameter to True.
+        "keep_movie_raw":
+            False,  # whether to keep binary file of non-registered frames.
+        "nimg_init": 300,  # subsampled frames for finding reference image
+        "batch_size": 500,  # number of frames per batch
+        "maxregshift":
+            0.1,  # max allowed registration shift, as a fraction of frame max(width and height)
+        "align_by_chan":
+            1,  # when multi-channel, you can align by non-functional channel (1-based)
+        "reg_tif": False,  # whether to save registered tiffs
+        "reg_tif_chan2": False,  # whether to save channel 2 registered tiffs
+        "subpixel": 10,  # precision of subpixel registration (1/subpixel steps)
+        "smooth_sigma_time": 0,  # gaussian smoothing in time
+        "smooth_sigma":
+            1.15,  # ~1 good for 2P recordings, recommend 3-5 for 1P recordings
+        "th_badframes":
+            1.0,
+        # this parameter determines which frames to exclude when determining cropping - set it smaller to exclude more frames
+        "norm_frames": True,  # normalize frames when detecting shifts
+        "force_refImg": False,  # if True, use refImg stored in ops if available
+        "pad_fft": False,  # if True, pads image during FFT part of registration
+
+        # non rigid registration settings
+        "nonrigid": True,  # whether to use nonrigid registration
+        "block_size": [128,
+                       128],  # block size to register (** keep this a multiple of 2 **)
+        "snr_thresh":
+            1.2,
+        # if any nonrigid block is below this threshold, it gets smoothed until above this threshold. 1.0 results in no smoothing
+        "maxregshiftNR":
+            5,  # maximum pixel shift allowed for nonrigid, relative to rigid
+
+        # 1P settings
+        "1Preg": False,  # whether to perform high-pass filtering and tapering
+        "spatial_hp_reg":
+            42,  # window for spatial high-pass filtering before registration
+        "pre_smooth":
+            0,  # whether to smooth before high-pass filtering before registration
+        "spatial_taper":
+            40,
+        # how much to ignore on edges (important for vignetted windows, for FFT padding do not set BELOW 3*ops["smooth_sigma"])
+
+        # cell detection settings with suite2p
+        "roidetect": True,  # whether or not to run ROI extraction
+        "spikedetect": True,  # whether or not to run spike deconvolution
+        "sparse_mode": True,  # whether or not to run sparse_mode
+        "spatial_scale":
+            1,  # 0: multi-scale; 1: 6 pixels, 2: 12 pixels, 3: 24 pixels, 4: 48 pixels
+        "connected":
+            True,  # whether or not to keep ROIs fully connected (set to 0 for dendrites)
+        "nbinned": 5000,  # max number of binned frames for cell detection
+        "max_iterations": 20,  # maximum number of iterations to do cell detection
+        "threshold_scaling":
+            1.0,  # adjust the automatically determined threshold by this scalar multiplier
+        "max_overlap":
+            0.75,  # cells with more overlap than this get removed during triage, before refinement
+        "high_pass":
+            100,  # running mean subtraction across bins with a window of size "high_pass" (use low values for 1P)
+        "spatial_hp_detect":
+            25,  # window for spatial high-pass filtering for neuropil subtraction before detection
+        "denoise": False,  # denoise binned movie for cell detection in sparse_mode
+
+        # cell detection settings with cellpose (used if anatomical_only > 0)
+        "anatomical_only":
+            3,
+        # run cellpose to get masks on 1: max_proj / mean_img; 2: mean_img; 3: mean_img enhanced, 4: max_proj
+        "diameter": 6,  # use diameter for cellpose, if 0 estimate diameter
+        "cellprob_threshold": -6,  # cellprob_threshold for cellpose
+        "flow_threshold": 0,  # flow_threshold for cellpose
+        "spatial_hp_cp": 0.5,  # high-pass image spatially by a multiple of the diameter
+        "pretrained_model":
+            "cpsam",  # path to pretrained model or model type string in Cellpose (can be user model)
+
+        # classification parameters
+        "soma_crop":
+            True,  # crop dendrites for cell classification stats like compactness
+        # ROI extraction parameters
+        "neuropil_extract":
+            True,  # whether or not to extract neuropil; if False, Fneu is set to zero
+        "inner_neuropil_radius":
+            2,  # number of pixels to keep between ROI and neuropil donut
+        "min_neuropil_pixels": 350,  # minimum number of pixels in the neuropil
+        "lam_percentile":
+            50.,  # percentile of lambda within area to ignore when excluding cell pixels for neuropil extraction
+        "allow_overlap":
+            False,  # pixels that are overlapping are thrown out (False) or added to both ROIs (True)
+        "use_builtin_classifier":
+            False,  # whether or not to use built-in classifier for cell detection (overrides
+        # classifier specified in classifier_path if set to True)
+        "classifier_path": "",  # path to classifier
+
+        # channel 2 detection settings (stat[n]["chan2"], stat[n]["not_chan2"])
+        "chan2_thres": 0.65,  # minimum for detection of brightness on channel 2
+
+        # deconvolution settings
+        "baseline": "maximin",  # baselining mode (can also choose "prctile")
+        "win_baseline": 60.,  # window for maximin
+        "sig_baseline": 10.,  # smoothing constant for gaussian filter
+        "prctile_baseline": 8.,  # optional (whether to use a percentile baseline)
+        "neucoeff": 0.7,  # neuropil coefficient
+    }
+
+
+def default_ops(metadata=None, ops=None):
+    """
+    Returns default ops for Suite2P processing on Light Beads Microscopy datasets.
+
+    Main changes to defaults:
+
+        anatomical_only=3
+        diameter=6
+        spatial_hp_cp=0.5
+        cellprob_threshold=-6
+        flow_threshold=0
+        spatial_scale=1
+        tau=1.3
+
+    Parameters
+    ----------
+    metadata : dict, optional
+        Metadata dictionary containing information about the dataset.
+    ops : dict, str or Path, optional
+        Path to or dict of suite2p ops.
+
+    Returns
+    -------
+    dict
+        Default ops for Suite2P processing.
+
+    Examples
+    --------
+    >>> import lbm_suite2p_python as lsp
+    >>> metadata = mbo.get_metadata("D://demo//raw_data//raw_file_00001.tif")  # noqa
+    >>> lsp.run_plane(
+    >>>    ops=ops,
+    >>>    input_tiff="D://demo//raw_data//raw_file_00001.tif",
+    >>>    save_path="D://demo//results",
+    >>>    save_folder="v1"
+    >>> )
+    """
+    if ops is None:
+        print("Importing suite2p packages...")
+        ops = s2p_ops()
+
+    if metadata is not None:
+        ops["fs"] = metadata["frame_rate"]
+        ops["dx"] = [metadata["pixel_resolution"][0]]
+        ops["dy"] = [metadata["pixel_resolution"][1]]
+
+    ops["nplanes"] = 1
+    ops["nchannels"] = 1
+    return ops

{lbm_suite2p_python-2.0.5 → lbm_suite2p_python-2.2.0}/lbm_suite2p_python/merging.py

@@ -87,8 +87,89 @@ def _merge_images(
 
 def merge_mrois(input_dir, output_dir, overwrite=True):
     """
-    Merge Suite2p outputs from multiple ROIs into per-plane outputs.
-    Will attempt to merge everything available; skips missing files gracefully.
+    Merge Suite2p outputs from multiple ROIs per plane into unified per-plane outputs.
+
+    This function is called automatically by run_volume() when multi-ROI data is detected
+    (filenames containing "roi"). It performs horizontal stitching of images and concatenation
+    of ROI statistics and traces.
+
+    Parameters
+    ----------
+    input_dir : str or Path
+        Directory containing per-ROI subdirectories with naming pattern "planeXX_roiYY/".
+        Each subdirectory should contain Suite2p outputs (ops.npy, stat.npy, F.npy, etc.).
+    output_dir : str or Path
+        Directory where merged outputs will be saved. Creates subdirectories named "planeXX/"
+        for each unique plane number found in input_dir.
+    overwrite : bool, default True
+        If True, overwrites existing merged outputs. If False, skips planes that already
+        have merged ops.npy files.
+
+    Notes
+    -----
+    **Merging Process:**
+
+    1. **ROI Grouping**: Groups directories by plane number
+       - Input: "plane01_roi01/", "plane01_roi02/", "plane02_roi01/"
+       - Groups: {"plane01": [roi01, roi02], "plane02": [roi01]}
+
+    2. **Image Stitching**: Horizontally concatenates images
+       - Full-FOV images (refImg, meanImg, meanImgE): Simple horizontal stacking
+       - Cropped images (max_proj, Vcorr): Placed at yrange/xrange with horizontal offset
+       - Final dimensions: Ly = max(ROI heights), Lx = sum(ROI widths)
+
+    3. **ROI Coordinate Adjustment**: Updates stat array pixel coordinates
+       - Adds horizontal offset to stat["xpix"] for each ROI
+       - Updates stat["med"] centroid positions
+       - Recalculates stat["ipix_neuropil"] linear indices
+
+    4. **Trace Concatenation**: Vertically stacks fluorescence traces
+       - Concatenates F, Fneu, spks arrays along axis 0 (ROI dimension)
+       - Preserves temporal dimension (axis 1)
+       - Result shape: (total_neurons, nframes)
+
+    5. **Binary Stitching**: Creates horizontally stitched binary files
+       - Reads frame-by-frame from each ROI binary
+       - Horizontally stacks frames using np.hstack()
+       - Writes to merged data.bin
+       - Handles frame count mismatches by using minimum nframes
+
+    6. **Metadata Merging**: Combines ops dictionaries
+       - Uses first ROI's ops as base
+       - Updates Lx to sum of ROI widths
+       - Updates xrange to [0, total_Lx]
+       - Preserves registration offsets if identical across ROIs
+
+    **Output Structure:**
+
+    For input::
+
+        input_dir/
+        ├── plane01_roi01/
+        │   ├── ops.npy (Lx=512)
+        │   ├── stat.npy (100 neurons)
+        │   ├── F.npy (100, 5000)
+        │   └── data_raw.bin
+        └── plane01_roi02/
+            ├── ops.npy (Lx=512)
+            ├── stat.npy (120 neurons)
+            ├── F.npy (120, 5000)
+            └── data_raw.bin
+
+    Creates output::
+
+        output_dir/
+        └── plane01/
+            ├── ops.npy (Lx=1024, nrois=2)
+            ├── stat.npy (220 neurons with adjusted xpix)
+            ├── F.npy (220, 5000)
+            ├── data.bin (horizontally stitched, shape: nframes × Ly × 1024)
+            └── [merged visualization PNGs]
+
+    See Also
+    --------
+    merge_zarr_rois : Similar merging for ZARR format
+    run_volume : Automatically calls this function when multi-ROI data detected
     """
     input_dir = Path(input_dir)
     output_dir = Path(output_dir)

{lbm_suite2p_python-2.0.5 → lbm_suite2p_python-2.2.0}/lbm_suite2p_python/postprocessing.py

@@ -395,14 +395,29 @@ def load_planar_results(ops: dict | str | Path, z_plane: list | int = None) -> d
 
     save_path = Path(output_ops["save_path"])
 
-    F = np.load(save_path.joinpath("F.npy"))
-    Fneu = np.load(save_path.joinpath("Fneu.npy"))
-    spks = np.load(save_path.joinpath("spks.npy"))
-    stat = np.load(save_path.joinpath("stat.npy"), allow_pickle=True)
-    iscell = np.load(save_path.joinpath("iscell.npy"), allow_pickle=True)[:, 0].astype(
+    # Check all required files exist
+    required_files = {
+        "F.npy": save_path / "F.npy",
+        "Fneu.npy": save_path / "Fneu.npy",
+        "spks.npy": save_path / "spks.npy",
+        "stat.npy": save_path / "stat.npy",
+        "iscell.npy": save_path / "iscell.npy",
+    }
+
+    missing_files = [name for name, path in required_files.items() if not path.exists()]
+    if missing_files:
+        raise FileNotFoundError(
+            f"Missing required files in {save_path}: {', '.join(missing_files)}"
+        )
+
+    F = np.load(required_files["F.npy"])
+    Fneu = np.load(required_files["Fneu.npy"])
+    spks = np.load(required_files["spks.npy"])
+    stat = np.load(required_files["stat.npy"], allow_pickle=True)
+    iscell = np.load(required_files["iscell.npy"], allow_pickle=True)[:, 0].astype(
         bool
     )
-    cellprob = np.load(save_path.joinpath("iscell.npy"), allow_pickle=True)[:, 1]
+    cellprob = np.load(required_files["iscell.npy"], allow_pickle=True)[:, 1]
     # model = np.load(save_path.joinpath("model.npy"), allow_pickle=True).item()
 
     n_neurons = spks.shape[0]