spacr 0.0.1__py3-none-any.whl → 0.0.6__py3-none-any.whl

spacr/annotate_app.py

@@ -13,38 +13,17 @@ from ttkthemes import ThemedTk
 
 from .logger import log_function_call
 
-from .gui_utils import ScrollableFrame, set_default_font, set_dark_style, create_dark_mode
+from .gui_utils import ScrollableFrame, set_default_font, set_dark_style, create_dark_mode, style_text_boxes, create_menu_bar
 
 class ImageApp:
-    """
-    A class representing an image application.
-
-    Attributes:
-    - root (tkinter.Tk): The root window of the application.
-    - db_path (str): The path to the SQLite database.
-    - index (int): The index of the current page of images.
-    - grid_rows (int): The number of rows in the image grid.
-    - grid_cols (int): The number of columns in the image grid.
-    - image_size (tuple): The size of the displayed images.
-    - annotation_column (str): The column name for image annotations in the database.
-    - image_type (str): The type of images to display.
-    - channels (list): The channels to filter in the images.
-    - images (dict): A dictionary mapping labels to loaded images.
-    - pending_updates (dict): A dictionary of pending image annotation updates.
-    - labels (list): A list of label widgets for displaying images.
-    - terminate (bool): A flag indicating whether the application should terminate.
-    - update_queue (Queue): A queue for storing image annotation updates.
-    - status_label (tkinter.Label): A label widget for displaying status messages.
-    - db_update_thread (threading.Thread): A thread for updating the database.
-    """
-
-    def _init_(self, root, db_path, image_type=None, channels=None, grid_rows=None, grid_cols=None, image_size=(200, 200), annotation_column='annotate'):
+    def __init__(self, root, db_path, src, image_type=None, channels=None, grid_rows=None, grid_cols=None, image_size=(200, 200), annotation_column='annotate'):
         """
         Initializes an instance of the ImageApp class.
 
         Parameters:
         - root (tkinter.Tk): The root window of the application.
         - db_path (str): The path to the SQLite database.
+        - src (str): The source directory that should be upstream of 'data' in the paths.
         - image_type (str): The type of images to display.
         - channels (list): The channels to filter in the images.
         - grid_rows (int): The number of rows in the image grid.
@@ -52,9 +31,9 @@ class ImageApp:
         - image_size (tuple): The size of the displayed images.
         - annotation_column (str): The column name for image annotations in the database.
         """
-
         self.root = root
         self.db_path = db_path
+        self.src = src
         self.index = 0
         self.grid_rows = grid_rows
         self.grid_cols = grid_cols
@@ -65,7 +44,7 @@ class ImageApp:
         self.images = {}
         self.pending_updates = {}
         self.labels = []
-        #self.updating_db = True
+        self.adjusted_to_original_paths = {}
         self.terminate = False
         self.update_queue = Queue()
         self.status_label = Label(self.root, text="", font=("Arial", 12))
@@ -78,6 +57,68 @@ class ImageApp:
             label = Label(root)
             label.grid(row=i // grid_cols, column=i % grid_cols)
             self.labels.append(label)
+
+    def load_images(self):
+        """
+        Loads and displays images with annotations.
+
+        This method retrieves image paths and annotations from a SQLite database,
+        loads the images using a ThreadPoolExecutor for parallel processing,
+        adds colored borders to images based on their annotations,
+        and displays the images in the corresponding labels.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        for label in self.labels:
+            label.config(image='')
+
+        self.images = {}
+
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        if self.image_type:
+            c.execute(f"SELECT png_path, {self.annotation_column} FROM png_list WHERE png_path LIKE ? LIMIT ?, ?", (f"%{self.image_type}%", self.index, self.grid_rows * self.grid_cols))
+        else:
+            c.execute(f"SELECT png_path, {self.annotation_column} FROM png_list LIMIT ?, ?", (self.index, self.grid_rows * self.grid_cols))
+        
+        paths = c.fetchall()
+        conn.close()
+
+        adjusted_paths = []
+        for path, annotation in paths:
+            if not path.startswith(self.src):
+                parts = path.split('/data/')
+                if len(parts) > 1:
+                    new_path = os.path.join(self.src, 'data', parts[1])
+                    self.adjusted_to_original_paths[new_path] = path
+                    adjusted_paths.append((new_path, annotation))
+                else:
+                    adjusted_paths.append((path, annotation))
+            else:
+                adjusted_paths.append((path, annotation))
+
+        with ThreadPoolExecutor() as executor:
+            loaded_images = list(executor.map(self.load_single_image, adjusted_paths))
+
+        for i, (img, annotation) in enumerate(loaded_images):
+            if annotation:
+                border_color = 'teal' if annotation == 1 else 'red'
+                img = self.add_colored_border(img, border_width=5, border_color=border_color)
+
+            photo = ImageTk.PhotoImage(img)
+            label = self.labels[i]
+            self.images[label] = photo
+            label.config(image=photo)
+
+            path = adjusted_paths[i][0]
+            label.bind('<Button-1>', self.get_on_image_click(path, label, img))
+            label.bind('<Button-3>', self.get_on_image_click(path, label, img))
+
+        self.root.update()
         
     @staticmethod
     def normalize_image(img):
@@ -148,55 +189,6 @@ class ImageApp:
 
         return Image.merge("RGB", (r, g, b))
 
-    def load_images(self):
-            """
-            Loads and displays images with annotations.
-
-            This method retrieves image paths and annotations from a SQLite database,
-            loads the images using a ThreadPoolExecutor for parallel processing,
-            adds colored borders to images based on their annotations,
-            and displays the images in the corresponding labels.
-
-            Args:
-                None
-
-            Returns:
-                None
-            """
-            for label in self.labels:
-                label.config(image='')
-
-            self.images = {}
-
-            conn = sqlite3.connect(self.db_path)
-            c = conn.cursor()
-            if self.image_type:
-                c.execute(f"SELECT png_path, {self.annotation_column} FROM png_list WHERE png_path LIKE ? LIMIT ?, ?", (f"%{self.image_type}%", self.index, self.grid_rows * self.grid_cols))
-            else:
-                c.execute(f"SELECT png_path, {self.annotation_column} FROM png_list LIMIT ?, ?", (self.index, self.grid_rows * self.grid_cols))
-            
-            paths = c.fetchall()
-            conn.close()
-
-            with ThreadPoolExecutor() as executor:
-                loaded_images = list(executor.map(self.load_single_image, paths))
-
-            for i, (img, annotation) in enumerate(loaded_images):
-                if annotation:
-                    border_color = 'teal' if annotation == 1 else 'red'
-                    img = self.add_colored_border(img, border_width=5, border_color=border_color)
-                
-                photo = ImageTk.PhotoImage(img)
-                label = self.labels[i]
-                self.images[label] = photo
-                label.config(image=photo)
-                
-                path = paths[i][0]
-                label.bind('<Button-1>', self.get_on_image_click(path, label, img))
-                label.bind('<Button-3>', self.get_on_image_click(path, label, img))
-
-            self.root.update()
-
     def load_single_image(self, path_annotation_tuple):
             """
             Loads a single image from the given path and annotation tuple.
@@ -230,14 +222,15 @@ class ImageApp:
         function: The callback function for the image click event.
         """
         def on_image_click(event):
-            
             new_annotation = 1 if event.num == 1 else (2 if event.num == 3 else None)
             
-            if path in self.pending_updates and self.pending_updates[path] == new_annotation:
-                self.pending_updates[path] = None
+            original_path = self.adjusted_to_original_paths.get(path, path)
+            
+            if original_path in self.pending_updates and self.pending_updates[original_path] == new_annotation:
+                self.pending_updates[original_path] = None
                 new_annotation = None
             else:
-                self.pending_updates[path] = new_annotation
+                self.pending_updates[original_path] = new_annotation
             
             print(f"Image {os.path.split(path)[1]} annotated: {new_annotation}")
             
@@ -261,38 +254,38 @@ class ImageApp:
         """))
 
     def update_database_worker(self):
-            """
-            Worker function that continuously updates the database with pending updates from the update queue.
-            It retrieves the pending updates from the queue, updates the corresponding records in the database,
-            and resets the text in the HTML and status label.
-            """
-            conn = sqlite3.connect(self.db_path)
-            c = conn.cursor()
-
-            display(HTML("<div id='unique_id'>Initial Text</div>"))
-
-            while True:
-                if self.terminate:
-                    conn.close()
-                    break
-
-                if not self.update_queue.empty():
-                    ImageApp.update_html("Do not exit, Updating database...")
-                    self.status_label.config(text='Do not exit, Updating database...')
-
-                    pending_updates = self.update_queue.get()
-                    for path, new_annotation in pending_updates.items():
-                        if new_annotation is None:
-                            c.execute(f'UPDATE png_list SET {self.annotation_column} = NULL WHERE png_path = ?', (path,))
-                        else:
-                            c.execute(f'UPDATE png_list SET {self.annotation_column} = ? WHERE png_path = ?', (new_annotation, path))
-                    conn.commit()
-
-                    # Reset the text
-                    ImageApp.update_html('')
-                    self.status_label.config(text='')
-                    self.root.update()
-                time.sleep(0.1)
+        """
+        Worker function that continuously updates the database with pending updates from the update queue.
+        It retrieves the pending updates from the queue, updates the corresponding records in the database,
+        and resets the text in the HTML and status label.
+        """
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+
+        display(HTML("<div id='unique_id'>Initial Text</div>"))
+
+        while True:
+            if self.terminate:
+                conn.close()
+                break
+
+            if not self.update_queue.empty():
+                ImageApp.update_html("Do not exit, Updating database...")
+                self.status_label.config(text='Do not exit, Updating database...')
+
+                pending_updates = self.update_queue.get()
+                for path, new_annotation in pending_updates.items():
+                    if new_annotation is None:
+                        c.execute(f'UPDATE png_list SET {self.annotation_column} = NULL WHERE png_path = ?', (path,))
+                    else:
+                        c.execute(f'UPDATE png_list SET {self.annotation_column} = ? WHERE png_path = ?', (new_annotation, path))
+                conn.commit()
+
+                # Reset the text
+                ImageApp.update_html('')
+                self.status_label.config(text='')
+                self.root.update()
+            time.sleep(0.1)
 
     def update_gui_text(self, text):
         """
@@ -356,12 +349,13 @@ class ImageApp:
         self.root.destroy()
         print(f'Quit application')
 
-def annotate(db, image_type=None, channels=None, geom="1000x1100", img_size=(200, 200), rows=5, columns=5, annotation_column='annotate'):
+def annotate(src, image_type=None, channels=None, geom="1000x1100", img_size=(200, 200), rows=5, columns=5, annotation_column='annotate'):
     """
     Annotates images in a database using a graphical user interface.
 
     Args:
         db (str): The path to the SQLite database.
+        src (str): The source directory that should be upstream of 'data' in the paths.
         image_type (str, optional): The type of images to load from the database. Defaults to None.
         channels (str, optional): The channels of the images to load from the database. Defaults to None.
         geom (str, optional): The geometry of the GUI window. Defaults to "1000x1100".
@@ -370,7 +364,10 @@ def annotate(db, image_type=None, channels=None, geom="1000x1100", img_size=(200
         columns (int, optional): The number of columns in the image grid. Defaults to 5.
         annotation_column (str, optional): The name of the annotation column in the database table. Defaults to 'annotate'.
     """
-    #display(HTML("<div id='unique_id'>Initial Text</div>"))
+    db = os.path.join(src, 'measurements/measurements.db')
+    #print('src', src)
+    #print('db', db)
+
     conn = sqlite3.connect(db)
     c = conn.cursor()
     c.execute('PRAGMA table_info(png_list)')
@@ -382,8 +379,7 @@ def annotate(db, image_type=None, channels=None, geom="1000x1100", img_size=(200
 
     root = tk.Tk()
     root.geometry(geom)
-    app = ImageApp(root, db, image_type=image_type, channels=channels, image_size=img_size, grid_rows=rows, grid_cols=columns, annotation_column=annotation_column)
-    
+    app = ImageApp(root, db, src, image_type=image_type, channels=channels, image_size=img_size, grid_rows=rows, grid_cols=columns, annotation_column=annotation_column)
     next_button = tk.Button(root, text="Next", command=app.next_page)
     next_button.grid(row=app.grid_rows, column=app.grid_cols - 1)
     back_button = tk.Button(root, text="Back", command=app.previous_page)
@@ -394,6 +390,7 @@ def annotate(db, image_type=None, channels=None, geom="1000x1100", img_size=(200
     app.load_images()
     root.mainloop()
 
+
 def check_for_duplicates(db):
     """
     Check for duplicates in the given SQLite database.
@@ -419,13 +416,14 @@ def check_for_duplicates(db):
     conn.commit()
     conn.close()
 
-@log_function_call
+#@log_function_call
 def initiate_annotation_app_root(width, height):
     theme = 'breeze'
     root = ThemedTk(theme=theme)
     style = ttk.Style(root)
     set_dark_style(style)
-    set_default_font(root, font_name="Arial", size=10)
+    style_text_boxes(style)
+    set_default_font(root, font_name="Arial", size=8)
     root.geometry(f"{width}x{height}")
     root.title("Annotation App")
 
@@ -473,6 +471,7 @@ def initiate_annotation_app_root(width, height):
         new_root = tk.Tk()
         new_root.geometry(f"{width}x{height}")
         new_root.title("Mask Application")
+        
 
         # Start the annotation application in the new root window
         app_instance = annotate(db, image_type, channels, annotation_column, geom, img_size, rows, columns)
@@ -482,7 +481,7 @@ def initiate_annotation_app_root(width, height):
     create_dark_mode(root, style, console_output=None)
 
     run_button = ttk.Button(scrollable_frame.scrollable_frame, text="Run", command=run_app)
-    run_button.grid(row=row, column=0, columnspan=2, pady=10)
+    run_button.grid(row=row, column=0, columnspan=2, pady=10, padx=10)
 
     return root
 
@@ -491,5 +490,4 @@ def gui_annotation():
     root.mainloop()
 
 if __name__ == "__main__":
-    gui_annotation()
-
+    gui_annotation()

spacr/chris.py

@@ -0,0 +1,50 @@
+import pandas as pd 
+import numpy as np
+from .core import _permutation_importance, _shap_analysis
+
+def join_measurments_and_annotation(src, tables = ['cell', 'nucleus', 'pathogen','cytoplasm']):
+    
+    from .io import _read_and_merge_data, _read_db
+    
+    db_loc = [src+'/measurements/measurements.db']
+    loc = src+'/measurements/measurements.db'
+    df, _ = _read_and_merge_data(db_loc, 
+                                 tables, 
+                                 verbose=True, 
+                                 include_multinucleated=True, 
+                                 include_multiinfected=True, 
+                                 include_noninfected=True)
+    
+    paths_df = _read_db(loc, tables=['png_list'])
+
+    merged_df = pd.merge(df, paths_df[0], on='prcfo', how='left')
+
+    return merged_df
+
+def plate_heatmap(src, model_type='xgboost', variable='predictions', grouping='mean', min_max='allq', cmap='viridis', channel_of_interest=3, min_count=25, n_estimators=100, col_to_compare='col', pos='c1', neg='c2', exclude=None, n_repeats=10, clean=True, nr_to_plot=20, verbose=False, n_jobs=-1):
+    from .io import _read_and_merge_data
+    from .plot import _plot_plates
+
+    db_loc = [src+'/measurements/measurements.db']
+    tables = ['cell', 'nucleus', 'pathogen','cytoplasm']
+    include_multinucleated, include_multiinfected, include_noninfected = True, 2.0, True
+    
+    df = join_measurments_and_annotation(src, tables=['cell', 'nucleus', 'pathogen', 'cytoplasm'])
+        
+    if not channel_of_interest is None:
+        df['recruitment'] = df[f'pathogen_channel_{channel_of_interest}_mean_intensity']/df[f'cytoplasm_channel_{channel_of_interest}_mean_intensity']
+        feature_string = f'channel_{channel_of_interest}'
+    else:
+        feature_string = None
+    
+    output = _permutation_importance(df, feature_string, col_to_compare, pos, neg, exclude, n_repeats, clean, nr_to_plot, n_estimators=n_estimators, random_state=42, model_type=model_type, n_jobs=n_jobs)
+    
+    _shap_analysis(output[3], output[4], output[5])
+
+    features = output[0].select_dtypes(include=[np.number]).columns.tolist()
+
+    if not variable in features:
+        raise ValueError(f"Variable {variable} not found in the dataframe. Please choose one of the following: {features}")
+    
+    plate_heatmap = _plot_plates(output[0], variable, grouping, min_max, cmap, min_count)
+    return [output, plate_heatmap]

spacr/cli.py

@@ -4,200 +4,38 @@ Copyright © 2023 Howard Hughes Medical Institute, Authored by Carsen Stringer a
 
 import argparse
 
+import argparse
+
 
 def get_arg_parser():
-    """ Parses command line arguments for cellpose main function
+    """ Parses command line arguments for spacr main functions
 
     Note: this function has to be in a separate file to allow autodoc to work for CLI.
     The autodoc_mock_imports in conf.py does not work for sphinx-argparse sometimes,
     see https://github.com/ashb/sphinx-argparse/issues/9#issue-1097057823
     """
-
-    parser = argparse.ArgumentParser(description="Cellpose Command Line Parameters")
-
-    # misc settings
-    parser.add_argument("--version", action="store_true",
-                        help="show cellpose version info")
-    parser.add_argument(
-        "--verbose", action="store_true",
-        help="show information about running and settings and save to log")
-    parser.add_argument("--Zstack", action="store_true", help="run GUI in 3D mode")
-
-    # settings for CPU vs GPU
+    
+    parser = argparse.ArgumentParser(description="SPACR Mask App Command Line Parameters")
     hardware_args = parser.add_argument_group("Hardware Arguments")
-    hardware_args.add_argument("--use_gpu", action="store_true",
-                               help="use gpu if torch with cuda installed")
-    hardware_args.add_argument(
-        "--gpu_device", required=False, default="0", type=str,
-        help="which gpu device to use, use an integer for torch, or mps for M1")
-    hardware_args.add_argument("--check_mkl", action="store_true",
-                               help="check if mkl working")
-
-    # settings for locating and formatting images
     input_img_args = parser.add_argument_group("Input Image Arguments")
-    input_img_args.add_argument("--dir", default=[], type=str,
+    #model_args = parser.add_argument_group("Model Arguments")
+    #algorithm_args = parser.add_argument_group("Algorithm Arguments")
+    #training_args = parser.add_argument_group("Training Arguments")
+    #output_args = parser.add_argument_group("Output Arguments")
+    
+    # misc settings
+    parser.add_argument("--version", action="store_true",
+                        help="show version info")
+    # misc settings
+    parser.add_argument("--headless", action="store_true",
+                        help="run the app without the gui")
+    
+    parser.add_argument("--verbose", action="store_true",
+                        help="show information about running and settings and save to log")
+    
+    hardware_args.add_argument("--gpu_device", required=False, default="0", type=str,
+                               help="which gpu device to use, use an integer for torch, or mps for M1")
+    
+    input_img_args.add_argument("--src", default=[], type=str,
                                 help="folder containing data to run or train on.")
-    input_img_args.add_argument(
-        "--image_path", default=[], type=str, help=
-        "if given and --dir not given, run on single image instead of folder (cannot train with this option)"
-    )
-    input_img_args.add_argument(
-        "--look_one_level_down", action="store_true",
-        help="run processing on all subdirectories of current folder")
-    input_img_args.add_argument("--img_filter", default=[], type=str,
-                                help="end string for images to run on")
-    input_img_args.add_argument(
-        "--channel_axis", default=None, type=int,
-        help="axis of image which corresponds to image channels")
-    input_img_args.add_argument("--z_axis", default=None, type=int,
-                                help="axis of image which corresponds to Z dimension")
-    input_img_args.add_argument(
-        "--chan", default=0, type=int, help=
-        "channel to segment; 0: GRAY, 1: RED, 2: GREEN, 3: BLUE. Default: %(default)s")
-    input_img_args.add_argument(
-        "--chan2", default=0, type=int, help=
-        "nuclear channel (if cyto, optional); 0: NONE, 1: RED, 2: GREEN, 3: BLUE. Default: %(default)s"
-    )
-    input_img_args.add_argument("--invert", action="store_true",
-                                help="invert grayscale channel")
-    input_img_args.add_argument(
-        "--all_channels", action="store_true", help=
-        "use all channels in image if using own model and images with special channels")
-
-    # model settings
-    model_args = parser.add_argument_group("Model Arguments")
-    model_args.add_argument("--pretrained_model", required=False, default="cyto",
-                            type=str,
-                            help="model to use for running or starting training")
-    model_args.add_argument("--restore_type", required=False, default=None,
-                            type=str,
-                            help="model to use for image restoration")
-    model_args.add_argument("--chan2_restore", action="store_true",
-                               help="use nuclei restore model for second channel")
-    model_args.add_argument(
-        "--add_model", required=False, default=None, type=str,
-        help="model path to copy model to hidden .cellpose folder for using in GUI/CLI")
-
-    # algorithm settings
-    algorithm_args = parser.add_argument_group("Algorithm Arguments")
-    algorithm_args.add_argument(
-        "--no_resample", action="store_true", help=
-        "disable dynamics on full image (makes algorithm faster for images with large diameters)"
-    )
-    algorithm_args.add_argument(
-        "--no_interp", action="store_true",
-        help="do not interpolate when running dynamics (was default)")
-    algorithm_args.add_argument("--no_norm", action="store_true",
-                                help="do not normalize images (normalize=False)")
-    algorithm_args.add_argument(
-        "--do_3D", action="store_true",
-        help="process images as 3D stacks of images (nplanes x nchan x Ly x Lx")
-    algorithm_args.add_argument(
-        "--diameter", required=False, default=30., type=float, help=
-        "cell diameter, if 0 will use the diameter of the training labels used in the model, or with built-in model will estimate diameter for each image"
-    )
-    algorithm_args.add_argument(
-        "--stitch_threshold", required=False, default=0.0, type=float,
-        help="compute masks in 2D then stitch together masks with IoU>0.9 across planes"
-    )
-    algorithm_args.add_argument(
-        "--min_size", required=False, default=15, type=int,
-        help="minimum number of pixels per mask, can turn off with -1")
-
-    algorithm_args.add_argument(
-        "--flow_threshold", default=0.4, type=float, help=
-        "flow error threshold, 0 turns off this optional QC step. Default: %(default)s")
-    algorithm_args.add_argument(
-        "--cellprob_threshold", default=0, type=float,
-        help="cellprob threshold, default is 0, decrease to find more and larger masks")
-    algorithm_args.add_argument(
-        "--niter", default=0, type=int,
-        help="niter, number of iterations for dynamics for mask creation, default of 0 means it is proportional to diameter, set to a larger number like 2000 for very long ROIs")
-
-    algorithm_args.add_argument("--anisotropy", required=False, default=1.0, type=float,
-                                help="anisotropy of volume in 3D")
-    algorithm_args.add_argument("--exclude_on_edges", action="store_true",
-                                help="discard masks which touch edges of image")
-    algorithm_args.add_argument(
-        "--augment", action="store_true",
-        help="tiles image with overlapping tiles and flips overlapped regions to augment"
-    )
-
-    # output settings
-    output_args = parser.add_argument_group("Output Arguments")
-    output_args.add_argument(
-        "--save_png", action="store_true",
-        help="save masks as png and outlines as text file for ImageJ")
-    output_args.add_argument(
-        "--save_tif", action="store_true",
-        help="save masks as tif and outlines as text file for ImageJ")
-    output_args.add_argument("--no_npy", action="store_true",
-                             help="suppress saving of npy")
-    output_args.add_argument(
-        "--savedir", default=None, type=str, help=
-        "folder to which segmentation results will be saved (defaults to input image directory)"
-    )
-    output_args.add_argument(
-        "--dir_above", action="store_true", help=
-        "save output folders adjacent to image folder instead of inside it (off by default)"
-    )
-    output_args.add_argument("--in_folders", action="store_true",
-                             help="flag to save output in folders (off by default)")
-    output_args.add_argument(
-        "--save_flows", action="store_true", help=
-        "whether or not to save RGB images of flows when masks are saved (disabled by default)"
-    )
-    output_args.add_argument(
-        "--save_outlines", action="store_true", help=
-        "whether or not to save RGB outline images when masks are saved (disabled by default)"
-    )
-    output_args.add_argument(
-        "--save_rois", action="store_true",
-        help="whether or not to save ImageJ compatible ROI archive (disabled by default)"
-    )
-    output_args.add_argument(
-        "--save_txt", action="store_true",
-        help="flag to enable txt outlines for ImageJ (disabled by default)")
-    output_args.add_argument(
-        "--save_mpl", action="store_true",
-        help="save a figure of image/mask/flows using matplotlib (disabled by default). "
-        "This is slow, especially with large images.")
-
-    # training settings
-    training_args = parser.add_argument_group("Training Arguments")
-    training_args.add_argument("--train", action="store_true",
-                               help="train network using images in dir")
-    training_args.add_argument("--train_size", action="store_true",
-                               help="train size network at end of training")
-    training_args.add_argument("--test_dir", default=[], type=str,
-                               help="folder containing test data (optional)")
-    training_args.add_argument(
-        "--mask_filter", default="_masks", type=str, help=
-        "end string for masks to run on. use '_seg.npy' for manual annotations from the GUI. Default: %(default)s"
-    )
-    training_args.add_argument(
-        "--diam_mean", default=30., type=float, help=
-        "mean diameter to resize cells to during training -- if starting from pretrained models it cannot be changed from 30.0"
-    )
-    training_args.add_argument("--learning_rate", default=0.2, type=float,
-                               help="learning rate. Default: %(default)s")
-    training_args.add_argument("--weight_decay", default=0.00001, type=float,
-                               help="weight decay. Default: %(default)s")
-    training_args.add_argument("--n_epochs", default=500, type=int,
-                               help="number of epochs. Default: %(default)s")
-    training_args.add_argument("--batch_size", default=8, type=int,
-                               help="batch size. Default: %(default)s")
-    training_args.add_argument(
-        "--min_train_masks", default=5, type=int, help=
-        "minimum number of masks a training image must have to be used. Default: %(default)s"
-    )
-    training_args.add_argument("--SGD", default=1, type=int, help="use SGD")
-    training_args.add_argument(
-        "--save_every", default=100, type=int,
-        help="number of epochs to skip between saves. Default: %(default)s")
-    training_args.add_argument(
-        "--model_name_out", default=None, type=str,
-        help="Name of model to save as, defaults to name describing model architecture. "
-        "Model is saved in the folder specified by --dir in models subfolder.")
-
-    return parser
+    return parser