cellfinder 1.6.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

cellfinder/core/main.py

@@ -1,34 +1,33 @@
 import os
 from typing import Callable, List, Optional, Tuple
 
-import numpy as np
 from brainglobe_utils.cells.cells import Cell
 
-from cellfinder.core import logger
+from cellfinder.core import logger, types
 from cellfinder.core.download.download import model_type
 from cellfinder.core.train.train_yaml import depth_type
 
 
 def main(
-    signal_array: np.ndarray,
-    background_array: np.ndarray,
-    voxel_sizes: Tuple[int, int, int],
+    signal_array: types.array,
+    background_array: types.array,
+    voxel_sizes: Tuple[float, float, float],
     start_plane: int = 0,
     end_plane: int = -1,
     trained_model: Optional[os.PathLike] = None,
     model_weights: Optional[os.PathLike] = None,
     model: model_type = "resnet50_tv",
-    batch_size: int = 64,
+    classification_batch_size: int = 64,
     n_free_cpus: int = 2,
-    network_voxel_sizes: Tuple[int, int, int] = (5, 1, 1),
-    soma_diameter: int = 16,
-    ball_xy_size: int = 6,
-    ball_z_size: int = 15,
+    network_voxel_sizes: Tuple[float, float, float] = (5, 1, 1),
+    soma_diameter: float = 16,
+    ball_xy_size: float = 6,
+    ball_z_size: float = 15,
     ball_overlap_fraction: float = 0.6,
     log_sigma_size: float = 0.2,
     n_sds_above_mean_thresh: float = 10,
     soma_spread_factor: float = 1.4,
-    max_cluster_size: int = 100000,
+    max_cluster_size: float = 100000,
     cube_width: int = 50,
     cube_height: int = 50,
     cube_depth: int = 20,
@@ -36,8 +35,13 @@ def main(
     skip_detection: bool = False,
     skip_classification: bool = False,
     detected_cells: List[Cell] = None,
-    classification_batch_size: Optional[int] = None,
-    classification_torch_device: str = "cpu",
+    detection_batch_size: Optional[int] = None,
+    torch_device: Optional[str] = None,
+    pin_memory: bool = False,
+    split_ball_xy_size: float = 6,
+    split_ball_z_size: float = 15,
+    split_ball_overlap_fraction: float = 0.8,
+    n_splitting_iter: int = 10,
     *,
     detect_callback: Optional[Callable[[int], None]] = None,
     classify_callback: Optional[Callable[[int], None]] = None,
@@ -46,6 +50,111 @@ def main(
     """
     Parameters
     ----------
+    signal_array : numpy.ndarray or dask array
+        3D array representing the signal data in z, y, x order.
+    background_array : numpy.ndarray or dask array
+        3D array representing the signal data in z, y, x order.
+    voxel_sizes : 3-tuple of floats
+        Size of your voxels in the z, y, and x dimensions (microns).
+    start_plane : int
+        First plane index to process (inclusive, to process a subset of the
+        data).
+    end_plane : int
+        Last plane index to process (exclusive, to process a subset of the
+        data).
+    trained_model : Optional[Path]
+        Trained model file path (home directory (default) -> pretrained
+        weights).
+    model_weights : Optional[Path]
+        Model weights path (home directory (default) -> pretrained
+        weights).
+    model: str
+        Type of model to use. Defaults to `"resnet50_tv"`.
+    classification_batch_size : int
+        How many potential cells to classify at one time. The GPU/CPU
+        memory must be able to contain at once this many data cubes for
+        the models. For performance-critical applications, tune to maximize
+        memory usage without running out. Check your GPU/CPU memory to verify
+        it's not full.
+    n_free_cpus : int
+        How many CPU cores to leave free.
+    network_voxel_sizes : 3-tuple of floats
+        Size of the pre-trained network's voxels (microns) in the z, y, and x
+        dimensions.
+    soma_diameter : float
+        The expected in-plane (xy) soma diameter (microns).
+    ball_xy_size : float
+        3d filter's in-plane (xy) filter ball size (microns).
+    ball_z_size : float
+        3d filter's axial (z) filter ball size (microns).
+    ball_overlap_fraction : float
+        3d filter's fraction of the ball filter needed to be filled by
+        foreground voxels, centered on a voxel, to retain the voxel.
+    log_sigma_size : float
+        Gaussian filter width (as a fraction of soma diameter) used during
+        2d in-plane Laplacian of Gaussian filtering.
+    n_sds_above_mean_thresh : float
+        Intensity threshold (the number of standard deviations above
+        the mean) of the filtered 2d planes used to mark pixels as
+        foreground or background.
+    soma_spread_factor : float
+        Cell spread factor for determining the largest cell volume before
+        splitting up cell clusters. Structures with spherical volume of
+        diameter `soma_spread_factor * soma_diameter` or less will not be
+        split.
+    max_cluster_size : float
+        Largest detected cell cluster (in cubic um) where splitting
+        should be attempted. Clusters above this size will be labeled
+        as artifacts.
+    cube_width: int
+        The width of the data cube centered on the cell used for
+        classification. Defaults to `50`.
+    cube_height: int
+        The height of the data cube centered on the cell used for
+        classification. Defaults to `50`.
+    cube_depth: int
+        The depth of the data cube centered on the cell used for
+        classification. Defaults to `20`.
+    network_depth: str
+        The network depth to use during classification. Defaults to `"50"`.
+    skip_detection : bool
+        If selected, the detection step is skipped and instead we get the
+        detected cells from the cell layer below (from a previous
+        detection run or import).
+    skip_classification : bool
+        If selected, the classification step is skipped and all cells from
+        the detection stage are added.
+    detected_cells: Optional list of Cell objects.
+        If specified, the cells to use during classification.
+    detection_batch_size: int
+        The number of planes of the original data volume to process at
+        once. The GPU/CPU memory must be able to contain this many planes
+        for all the filters. For performance-critical applications, tune
+        to maximize memory usage without running out. Check your GPU/CPU
+        memory to verify it's not full.
+    torch_device : str, optional
+        The device on which to run the computation. If not specified (None),
+        "cuda" will be used if a GPU is available, otherwise "cpu".
+        You can also manually specify "cuda" or "cpu".
+    pin_memory: bool
+        Pins data to be sent to the GPU to the CPU memory. This allows faster
+        GPU data speeds, but can only be used if the data used by the GPU can
+        stay in the CPU RAM while the GPU uses it. I.e. there's enough RAM.
+        Otherwise, if there's a risk of the RAM being paged, it shouldn't be
+        used. Defaults to False.
+    split_ball_xy_size: float
+        Similar to `ball_xy_size`, except the value to use for the 3d
+        filter during cluster splitting.
+    split_ball_z_size: float
+        Similar to `ball_z_size`, except the value to use for the 3d filter
+        during cluster splitting.
+    split_ball_overlap_fraction: float
+        Similar to `ball_overlap_fraction`, except the value to use for the
+        3d filter during cluster splitting.
+    n_splitting_iter: int
+        The number of iterations to run the 3d filtering on a cluster. Each
+        iteration reduces the cluster size by the voxels not retained in
+        the previous iteration.
     detect_callback : Callable[int], optional
         Called every time a plane has finished being processed during the
         detection stage. Called with the plane number that has finished.
@@ -76,9 +185,14 @@ def main(
             n_free_cpus,
             log_sigma_size,
             n_sds_above_mean_thresh,
-            batch_size=classification_batch_size,
-            torch_device=classification_torch_device,
+            batch_size=detection_batch_size,
+            torch_device=torch_device,
+            pin_memory=pin_memory,
             callback=detect_callback,
+            split_ball_z_size=split_ball_z_size,
+            split_ball_xy_size=split_ball_xy_size,
+            split_ball_overlap_fraction=split_ball_overlap_fraction,
+            n_splitting_iter=n_splitting_iter,
         )
 
         if detect_finished_callback is not None:
@@ -101,7 +215,7 @@ def main(
                 n_free_cpus,
                 voxel_sizes,
                 network_voxel_sizes,
-                batch_size,
+                classification_batch_size,
                 cube_height,
                 cube_width,
                 cube_depth,

cellfinder/core/tools/threading.py

@@ -15,6 +15,7 @@ Typical example::
 
     from cellfinder.core.tools.threading import ThreadWithException, \\
         EOFSignal, ProcessWithException
+    from cellfinder.core import logger
     import torch
 
 
@@ -63,7 +64,7 @@ Typical example::
                     # thread exited for whatever reason (not exception)
                     break
 
-                print(f"Thread processed tensor {i}")
+                logger.debug(f"Thread processed tensor {i}")
         finally:
             # whatever happens, make sure thread is told to finish so it
             # doesn't get stuck
@@ -248,8 +249,8 @@ class ExceptionWithQueueMixIn:
             ...         # do something with the msg
             ...         pass
             ... except ExecutionFailure as e:
-            ...     print(f"got exception {type(e.__cause__)}")
-            ...     print(f"with message {e.__cause__.args[0]}")
+            ...     logger.error(f"got exception {type(e.__cause__)}")
+            ...     logger.error(f"with message {e.__cause__.args[0]}")
         """
         msg, value = self.from_thread_queue.get(block=True, timeout=timeout)
         if msg == "eof":

cellfinder/core/train/train_yaml.py

@@ -3,9 +3,6 @@ main
 ===============
 
 Trains a network based on a yaml file specifying cubes of cells/non cells.
-
-N.B imports are within functions to prevent tensorflow being imported before
-it's warnings are silenced
 """
 
 import os
@@ -29,12 +26,16 @@ from brainglobe_utils.general.system import (
 from brainglobe_utils.IO.cells import find_relevant_tiffs
 from brainglobe_utils.IO.yaml import read_yaml_section
 from fancylog import fancylog
+from keras.callbacks import CSVLogger, ModelCheckpoint, TensorBoard
 from sklearn.model_selection import train_test_split
 
 import cellfinder.core as program_for_log
 from cellfinder.core import logger
+from cellfinder.core.classify.cube_generator import CubeGeneratorFromDisk
 from cellfinder.core.classify.resnet import layer_type
+from cellfinder.core.classify.tools import get_model, make_lists
 from cellfinder.core.download.download import DEFAULT_DOWNLOAD_DIRECTORY
+from cellfinder.core.tools.prep import prep_model_weights
 
 depth_type = Literal["18", "34", "50", "101", "152"]
 
@@ -316,16 +317,6 @@ def run(
     save_progress=False,
     epochs=100,
 ):
-    from keras.callbacks import (
-        CSVLogger,
-        ModelCheckpoint,
-        TensorBoard,
-    )
-
-    from cellfinder.core.classify.cube_generator import CubeGeneratorFromDisk
-    from cellfinder.core.classify.tools import get_model, make_lists
-    from cellfinder.core.tools.prep import prep_model_weights
-
     start_time = datetime.now()
 
     ensure_directory_exists(output_dir)

cellfinder/napari/curation.py

@@ -95,6 +95,22 @@ class CurationWidget(QWidget):
                 self.training_data_non_cell_choice, self.point_layer_names
             )
 
+        @self.viewer.layers.events.removed.connect
+        def _remove_selection_layers(event: QtCore.QEvent):
+            """
+            Set internal background, signal, training data cell,
+            and training data non-cell layers to None when they
+            are removed from the napari viewer GUI.
+            """
+            if event.value == self.signal_layer:
+                self.signal_layer = None
+            if event.value == self.background_layer:
+                self.background_layer = None
+            if event.value == self.training_data_cell_layer:
+                self.training_data_cell_layer = None
+            if event.value == self.training_data_non_cell_layer:
+                self.training_data_non_cell_layer = None
+
     @staticmethod
     def _update_combobox_options(combobox: QComboBox, options_list: List[str]):
         original_text = combobox.currentText()
@@ -212,8 +228,8 @@ class CurationWidget(QWidget):
         self.layout.addWidget(self.load_data_panel, row, column, 1, 1)
 
     def setup_keybindings(self):
-        self.viewer.bind_key("c", self.mark_as_cell)
-        self.viewer.bind_key("x", self.mark_as_non_cell)
+        self.viewer.bind_key("c", self.mark_as_cell, overwrite=True)
+        self.viewer.bind_key("x", self.mark_as_non_cell, overwrite=True)
 
     def set_signal_image(self):
         """

cellfinder/napari/detect/detect.py

@@ -244,23 +244,26 @@ def detect_widget() -> FunctionGui:
         detection_options,
         skip_detection: bool,
         soma_diameter: float,
+        log_sigma_size: float,
+        n_sds_above_mean_thresh: float,
         ball_xy_size: float,
         ball_z_size: float,
         ball_overlap_fraction: float,
-        log_sigma_size: float,
-        n_sds_above_mean_thresh: int,
+        detection_batch_size: int,
         soma_spread_factor: float,
-        max_cluster_size: int,
+        max_cluster_size: float,
         classification_options,
         skip_classification: bool,
         use_pre_trained_weights: bool,
         trained_model: Optional[Path],
-        batch_size: int,
+        classification_batch_size: int,
         misc_options,
         start_plane: int,
         end_plane: int,
         n_free_cpus: int,
         analyse_local: bool,
+        use_gpu: bool,
+        pin_memory: bool,
         debug: bool,
         reset_button,
     ) -> None:
@@ -270,43 +273,60 @@ def detect_widget() -> FunctionGui:
         Parameters
         ----------
         voxel_size_z : float
-            Size of your voxels in the axial dimension
+            Size of your voxels in the axial dimension (microns)
         voxel_size_y : float
-            Size of your voxels in the y direction (top to bottom)
+            Size of your voxels in the y direction (top to bottom) (microns)
         voxel_size_x : float
-            Size of your voxels in the x direction (left to right)
+            Size of your voxels in the x direction (left to right) (microns)
         skip_detection : bool
             If selected, the detection step is skipped and instead we get the
             detected cells from the cell layer below (from a previous
             detection run or import)
         soma_diameter : float
-            The expected in-plane soma diameter (microns)
+            The expected in-plane (xy) soma diameter (microns)
+        log_sigma_size : float
+            Gaussian filter width (as a fraction of soma diameter) used during
+            2d in-plane Laplacian of Gaussian filtering
+        n_sds_above_mean_thresh : float
+            Intensity threshold (the number of standard deviations above
+            the mean) of the filtered 2d planes used to mark pixels as
+            foreground or background
         ball_xy_size : float
-            Elliptical morphological in-plane filter size (microns)
+            3d filter's in-plane (xy) filter ball size (microns)
         ball_z_size : float
-            Elliptical morphological axial filter size (microns)
+            3d filter's axial (z) filter ball size (microns)
         ball_overlap_fraction : float
-            Fraction of the morphological filter needed to be filled
-            to retain a voxel
-        log_sigma_size : float
-            Laplacian of Gaussian filter width (as a fraction of soma diameter)
-        n_sds_above_mean_thresh : int
-            Cell intensity threshold (as a multiple of noise above the mean)
+            3d filter's fraction of the ball filter needed to be filled by
+            foreground voxels, centered on a voxel, to retain the voxel
+        detection_batch_size: int
+            The number of planes of the original data volume to process at
+            once. The GPU/CPU memory must be able to contain this many planes
+            for all the filters. For performance-critical applications, tune
+            to maximize memory usage without
+            running out. Check your GPU/CPU memory to verify it's not full
         soma_spread_factor : float
-            Cell spread factor (for splitting up cell clusters)
-        max_cluster_size : int
-            Largest putative cell cluster (in cubic um) where splitting
-            should be attempted
-        use_pre_trained_weights : bool
-            Select to use pre-trained model weights
-        batch_size : int
-            How many points to classify at one time
+            Cell spread factor for determining the largest cell volume before
+            splitting up cell clusters. Structures with spherical volume of
+            diameter `soma_spread_factor * soma_diameter` or less will not be
+            split
+        max_cluster_size : float
+            Largest detected cell cluster (in cubic um) where splitting
+            should be attempted. Clusters above this size will be labeled
+            as artifacts
         skip_classification : bool
             If selected, the classification step is skipped and all cells from
             the detection stage are added
+        use_pre_trained_weights : bool
+            Select to use pre-trained model weights
         trained_model : Optional[Path]
             Trained model file path (home directory (default) -> pretrained
             weights)
+        classification_batch_size : int
+            How many potential cells to classify at one time. The GPU/CPU
+            memory must be able to contain at once this many data cubes for
+            the models. For performance-critical applications, tune to
+            maximize memory usage without running
+            out. Check your GPU/CPU memory to verify it's not full
         start_plane : int
             First plane to process (to process a subset of the data)
         end_plane : int
@@ -315,6 +335,14 @@ def detect_widget() -> FunctionGui:
             How many CPU cores to leave free
         analyse_local : bool
             Only analyse planes around the current position
+        use_gpu : bool
+            If True, use GPU for processing (if available); otherwise, use CPU.
+        pin_memory: bool
+            Pins data to be sent to the GPU to the CPU memory. This allows
+            faster GPU data speeds, but can only be used if the data used by
+            the GPU can stay in the CPU RAM while the GPU uses it. I.e. there's
+            enough RAM. Otherwise, if there's a risk of the RAM being paged, it
+            shouldn't be used. Defaults to False.
         debug : bool
             Increase logging
         reset_button :
@@ -370,6 +398,7 @@ def detect_widget() -> FunctionGui:
             n_sds_above_mean_thresh,
             soma_spread_factor,
             max_cluster_size,
+            detection_batch_size,
         )
 
         if use_pre_trained_weights:
@@ -378,7 +407,7 @@ def detect_widget() -> FunctionGui:
             skip_classification,
             use_pre_trained_weights,
             trained_model,
-            batch_size,
+            classification_batch_size,
         )
 
         if analyse_local:
@@ -389,7 +418,13 @@ def detect_widget() -> FunctionGui:
             end_plane = len(signal_image.data)
 
         misc_inputs = MiscInputs(
-            start_plane, end_plane, n_free_cpus, analyse_local, debug
+            start_plane,
+            end_plane,
+            n_free_cpus,
+            analyse_local,
+            use_gpu,
+            pin_memory,
+            debug,
         )
 
         worker = Worker(

cellfinder/napari/detect/detect_containers.py

@@ -1,8 +1,9 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import List, Optional
 
 import numpy
+import torch
 from brainglobe_utils.cells.cells import Cell
 
 from cellfinder.napari.input_container import InputContainer
@@ -30,7 +31,7 @@ class DataInputs(InputContainer):
             self.voxel_size_x,
         )
         # del operator doesn't affect self, because asdict creates a copy of
-        # fields.
+        # the dict.
         del data_input_dict["voxel_size_z"]
         del data_input_dict["voxel_size_y"]
         del data_input_dict["voxel_size_x"]
@@ -67,9 +68,10 @@ class DetectionInputs(InputContainer):
     ball_z_size: float = 15
     ball_overlap_fraction: float = 0.6
     log_sigma_size: float = 0.2
-    n_sds_above_mean_thresh: int = 10
+    n_sds_above_mean_thresh: float = 10
     soma_spread_factor: float = 1.4
-    max_cluster_size: int = 100000
+    max_cluster_size: float = 100000
+    detection_batch_size: int = 1
 
     def as_core_arguments(self) -> dict:
         return super().as_core_arguments()
@@ -96,14 +98,17 @@ class DetectionInputs(InputContainer):
                 "n_sds_above_mean_thresh", custom_label="Threshold"
             ),
             soma_spread_factor=cls._custom_widget(
-                "soma_spread_factor", custom_label="Cell spread"
+                "soma_spread_factor", custom_label="Split cell spread"
             ),
             max_cluster_size=cls._custom_widget(
                 "max_cluster_size",
-                custom_label="Max cluster",
+                custom_label="Split max cluster",
                 min=0,
                 max=10000000,
             ),
+            detection_batch_size=cls._custom_widget(
+                "detection_batch_size", custom_label="Batch size (detection)"
+            ),
         )
 
 
@@ -114,7 +119,7 @@ class ClassificationInputs(InputContainer):
     skip_classification: bool = False
     use_pre_trained_weights: bool = True
     trained_model: Optional[Path] = Path.home()
-    batch_size: int = 64
+    classification_batch_size: int = 64
 
     def as_core_arguments(self) -> dict:
         args = super().as_core_arguments()
@@ -132,7 +137,10 @@ class ClassificationInputs(InputContainer):
             skip_classification=dict(
                 value=cls.defaults()["skip_classification"]
             ),
-            batch_size=dict(value=cls.defaults()["batch_size"]),
+            classification_batch_size=dict(
+                value=cls.defaults()["classification_batch_size"],
+                label="Batch size (classification)",
+            ),
         )
 
 
@@ -144,10 +152,14 @@ class MiscInputs(InputContainer):
     end_plane: int = 0
     n_free_cpus: int = 2
     analyse_local: bool = False
+    use_gpu: bool = field(default_factory=lambda: torch.cuda.is_available())
+    pin_memory: bool = False
     debug: bool = False
 
     def as_core_arguments(self) -> dict:
         misc_input_dict = super().as_core_arguments()
+        misc_input_dict["torch_device"] = "cuda" if self.use_gpu else "cpu"
+        del misc_input_dict["use_gpu"]
         del misc_input_dict["debug"]
         del misc_input_dict["analyse_local"]
         return misc_input_dict
@@ -162,5 +174,16 @@ class MiscInputs(InputContainer):
                 "n_free_cpus", custom_label="Number of free CPUs"
             ),
             analyse_local=dict(value=cls.defaults()["analyse_local"]),
+            use_gpu=dict(
+                widget_type="CheckBox",
+                label="Use GPU",
+                value=cls.defaults()["use_gpu"],
+                enabled=torch.cuda.is_available(),
+            ),
+            pin_memory=dict(
+                widget_type="CheckBox",
+                label="Pin data to memory",
+                value=cls.defaults()["pin_memory"],
+            ),
             debug=dict(value=cls.defaults()["debug"]),
         )

cellfinder/napari/input_container.py

@@ -1,8 +1,18 @@
 from abc import abstractmethod
-from dataclasses import asdict, dataclass
+from dataclasses import dataclass, fields
 from typing import Optional
 
 
+def asdict_no_copy(obj: dataclass) -> dict:
+    """
+    Similar to `asdict`, except it makes no copies of the field values.
+    asdict will do a deep copy of field values that are non-basic objects.
+
+    It still creates a new dict to return, though.
+    """
+    return {field.name: getattr(obj, field.name) for field in fields(obj)}
+
+
 @dataclass
 class InputContainer:
     """Base for classes that contain inputs
@@ -23,7 +33,7 @@ class InputContainer:
         # Derived classes are not expected to be particularly
         # slow to instantiate, so use the default constructor
         # to avoid code repetition.
-        return asdict(cls())
+        return asdict_no_copy(cls())
 
     @abstractmethod
     def as_core_arguments(self) -> dict:
@@ -32,10 +42,10 @@ class InputContainer:
         The implementation provided here can be re-used in derived classes, if
         convenient.
         """
-        # note that asdict returns a new instance of a dict,
+        # note that asdict_no_copy returns a new instance of a dict,
         # so any subsequent modifications of this dict won't affect the class
         # instance
-        return asdict(self)
+        return asdict_no_copy(self)
 
     @classmethod
     def _custom_widget(

cellfinder/napari/train/train.py

@@ -25,14 +25,14 @@ def run_training(
     optional_training_inputs: OptionalTrainingInputs,
     misc_training_inputs: MiscTrainingInputs,
 ):
-    print("Running training")
+    show_info("Running training...")
     train_yaml(
         **training_data_inputs.as_core_arguments(),
         **optional_network_inputs.as_core_arguments(),
         **optional_training_inputs.as_core_arguments(),
         **misc_training_inputs.as_core_arguments(),
     )
-    print("Finished!")
+    show_info("Training finished!")
 
 
 def training_widget() -> FunctionGui:
@@ -60,7 +60,6 @@ def training_widget() -> FunctionGui:
         continue_training: bool,
         augment: bool,
         tensorboard: bool,
-        save_weights: bool,
         save_checkpoints: bool,
         save_progress: bool,
         epochs: int,
@@ -96,9 +95,6 @@ def training_widget() -> FunctionGui:
             Augment the training data to improve generalisation
         tensorboard : bool
             Log to output_directory/tensorboard
-        save_weights : bool
-            Only store the model weights, and not the full model
-            Useful to save storage space
         save_checkpoints : bool
             Store the model at intermediate points during training
         save_progress : bool
@@ -133,7 +129,6 @@ def training_widget() -> FunctionGui:
             continue_training,
             augment,
             tensorboard,
-            save_weights,
             save_checkpoints,
             save_progress,
             epochs,
@@ -147,6 +142,7 @@ def training_widget() -> FunctionGui:
         if yaml_files[0] == Path.home():  # type: ignore
             show_info("Please select a YAML file for training")
         else:
+            show_info("Starting training process...")
             worker = run_training(
                 training_data_inputs,
                 optional_network_inputs,

cellfinder/napari/train/train_containers.py

@@ -75,7 +75,6 @@ class OptionalTrainingInputs(InputContainer):
     continue_training: bool = False
     augment: bool = True
     tensorboard: bool = False
-    save_weights: bool = False
     save_checkpoints: bool = True
     save_progress: bool = True
     epochs: int = 100
@@ -98,7 +97,6 @@ class OptionalTrainingInputs(InputContainer):
             continue_training=cls._custom_widget("continue_training"),
             augment=cls._custom_widget("augment"),
             tensorboard=cls._custom_widget("tensorboard"),
-            save_weights=cls._custom_widget("save_weights"),
             save_checkpoints=cls._custom_widget("save_checkpoints"),
             save_progress=cls._custom_widget("save_progress"),
             epochs=cls._custom_widget("epochs"),