spacr 0.4.15__py3-none-any.whl → 0.5.0__py3-none-any.whl

spacr/submodules.py

@@ -1,14 +1,21 @@
-
-
-
 import seaborn as sns
-import os, random, sqlite3, re, shap
+import os, random, sqlite3, re, shap, string, time
 import pandas as pd
 import numpy as np
-import cellpose
+
 from skimage.measure import regionprops, label
+from skimage.transform import resize as sk_resize, rotate
+from skimage.exposure import rescale_intensity
+
+import cellpose
+from cellpose import models as cp_models
+from cellpose import train as train_cp
 from cellpose import models as cp_models
+from cellpose import io as cp_io
 from cellpose import train as train_cp
+from cellpose.metrics import aggregated_jaccard_index
+from cellpose.metrics import average_precision
+
 from IPython.display import display
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.inspection import permutation_importance
@@ -17,10 +24,545 @@ from scipy.stats import chi2_contingency, pearsonr
 from scipy.spatial.distance import cosine
 
 from sklearn.metrics import mean_absolute_error
-
+from skimage.measure import regionprops, label as sklabel 
 import matplotlib.pyplot as plt
 from natsort import natsorted
 
+from torch.utils.data import Dataset
+
+class CellposeLazyDataset(Dataset):
+    def __init__(self, image_files, label_files, settings, randomize=True, augment=False):
+        combined = list(zip(image_files, label_files))
+        if randomize:
+            random.shuffle(combined)
+        self.image_files, self.label_files = zip(*combined)
+        self.normalize = settings['normalize']
+        self.percentiles = settings.get('percentiles', [2, 99])
+        self.target_size = settings['target_size']
+        self.augment = augment
+
+    def __len__(self):
+        return len(self.image_files) * (8 if self.augment else 1)
+
+    def apply_augmentation(self, image, label, aug_idx):
+        if aug_idx == 1:
+            return rotate(image, 90, resize=False, preserve_range=True), rotate(label, 90, resize=False, preserve_range=True)
+        elif aug_idx == 2:
+            return rotate(image, 180, resize=False, preserve_range=True), rotate(label, 180, resize=False, preserve_range=True)
+        elif aug_idx == 3:
+            return rotate(image, 270, resize=False, preserve_range=True), rotate(label, 270, resize=False, preserve_range=True)
+        elif aug_idx == 4:
+            return np.fliplr(image), np.fliplr(label)
+        elif aug_idx == 5:
+            return np.flipud(image), np.flipud(label)
+        elif aug_idx == 6:
+            return np.fliplr(rotate(image, 90, resize=False, preserve_range=True)), np.fliplr(rotate(label, 90, resize=False, preserve_range=True))
+        elif aug_idx == 7:
+            return np.flipud(rotate(image, 90, resize=False, preserve_range=True)), np.flipud(rotate(label, 90, resize=False, preserve_range=True))
+        return image, label
+
+    def __getitem__(self, idx):
+        base_idx = idx // 8 if self.augment else idx
+        aug_idx = idx % 8 if self.augment else 0
+
+        image = cp_io.imread(self.image_files[base_idx])
+        label = cp_io.imread(self.label_files[base_idx])
+
+        if image.ndim == 3:
+            image = image.mean(axis=-1)
+
+        if image.max() > 1:
+            image = image / image.max()
+
+        if self.normalize:
+            lower_p, upper_p = np.percentile(image, self.percentiles)
+            image = rescale_intensity(image, in_range=(lower_p, upper_p), out_range=(0, 1))
+
+        image, label = self.apply_augmentation(image, label, aug_idx)
+
+        image_shape = (self.target_size, self.target_size)
+        image = sk_resize(image, image_shape, preserve_range=True, anti_aliasing=True).astype(np.float32)
+        label = sk_resize(label, image_shape, order=0, preserve_range=True, anti_aliasing=False).astype(np.uint8)
+
+        return image, label
+
+def train_cellpose(settings):
+    
+    from .settings import get_train_cellpose_default_settings
+    from .utils import save_settings
+    
+    settings = get_train_cellpose_default_settings(settings)
+    img_src = os.path.join(settings['src'], 'train', 'images')
+    mask_src = os.path.join(settings['src'], 'train', 'masks')
+    target_size = settings['target_size']
+
+    model_name = f"{settings['model_name']}_cyto_e{settings['n_epochs']}_X{target_size}_Y{target_size}.CP_model"
+    model_save_path = os.path.join(settings['src'], 'models', 'cellpose_model')
+    os.makedirs(model_save_path, exist_ok=True)
+
+    save_settings(settings, name=model_name)
+
+    model = cp_models.CellposeModel(gpu=True, model_type='cyto', diam_mean=30, pretrained_model='cyto')
+    cp_channels = [0, 0]
+
+    #train_image_files = sorted([os.path.join(img_src, f) for f in os.listdir(img_src) if f.endswith('.tif')])
+    #train_label_files = sorted([os.path.join(mask_src, f) for f in os.listdir(mask_src) if f.endswith('.tif')])
+    
+    image_filenames = set(f for f in os.listdir(img_src) if f.endswith('.tif'))
+    label_filenames = set(f for f in os.listdir(mask_src) if f.endswith('.tif'))
+
+    # Only keep files that are present in both folders
+    matched_filenames = sorted(image_filenames & label_filenames)
+
+    train_image_files = [os.path.join(img_src, f) for f in matched_filenames]
+    train_label_files = [os.path.join(mask_src, f) for f in matched_filenames]
+
+    train_dataset = CellposeLazyDataset(train_image_files, train_label_files, settings, randomize=True, augment=settings['augment'])
+
+    n_aug = 8 if settings['augment'] else 1
+    max_base_images = len(train_dataset) // n_aug if settings['augment'] else len(train_dataset)
+    n_base = min(settings['batch_size'], max_base_images)
+
+    unique_base_indices = list(range(max_base_images))
+    random.shuffle(unique_base_indices)
+    selected_indices = unique_base_indices[:n_base]
+
+    images, labels = [], []
+    for idx in selected_indices:
+        for aug_idx in range(n_aug):
+            i = idx * n_aug + aug_idx if settings['augment'] else idx
+            img, lbl = train_dataset[i]
+            images.append(img)
+            labels.append(lbl)
+    try:
+        plot_cellpose_batch(images, labels)
+    except:
+        print(f"could not print batch images")
+        
+    print(f"Training model with {len(images)} ber patch for {settings['n_epochs']} Epochs")
+
+    train_cp.train_seg(model.net,
+                       train_data=images,
+                       train_labels=labels,
+                       channels=cp_channels,
+                       save_path=model_save_path,
+                       n_epochs=settings['n_epochs'],
+                       batch_size=settings['batch_size'],
+                       learning_rate=settings['learning_rate'],
+                       weight_decay=settings['weight_decay'],
+                       model_name=model_name,
+                       save_every=max(1, (settings['n_epochs'] // 10)),
+                       rescale=False)
+
+    print(f"Model saved at: {model_save_path}/{model_name}")
+    
+def test_cellpose_model(settings):
+    
+    from .utils import save_settings, print_progress
+    from .settings import get_default_test_cellpose_model_settings
+    
+    def plot_cellpose_resilts(i, j, results_dir, img, lbl, pred, flow):
+        from . plot import generate_mask_random_cmap
+        fig, axs = plt.subplots(1, 5, figsize=(16, 4), gridspec_kw={'wspace': 0.1, 'hspace': 0.1})
+        cmap_lbl = generate_mask_random_cmap(lbl)
+        cmap_pred = generate_mask_random_cmap(pred)
+
+        axs[0].imshow(img, cmap='gray')
+        axs[0].set_title('Image')
+        axs[0].axis('off')
+
+        axs[1].imshow(lbl, cmap=cmap_lbl, interpolation='nearest')
+        axs[1].set_title('True Mask')
+        axs[1].axis('off')
+
+        axs[2].imshow(pred, cmap=cmap_pred, interpolation='nearest')
+        axs[2].set_title('Predicted Mask')
+        axs[2].axis('off')
+        
+        axs[3].imshow(flow[2], cmap='gray')
+        axs[3].set_title('Cell Probability')
+        axs[3].axis('off')
+
+        axs[4].imshow(flow[0], cmap='gray')
+        axs[4].set_title('Flows')
+        axs[4].axis('off')
+
+        save_path = os.path.join(results_dir, f"cellpose_result_{i+j:03d}.png")
+        plt.savefig(save_path, dpi=200, bbox_inches='tight')
+        plt.show()
+        plt.close(fig)
+        
+        
+    settings = get_default_test_cellpose_model_settings(settings)
+        
+    save_settings(settings, name='test_cellpose_model')
+    test_image_folder = os.path.join(settings['src'], 'test', 'images')
+    test_label_folder = os.path.join(settings['src'], 'test', 'masks')
+    results_dir = os.path.join(settings['src'], 'results')
+    os.makedirs(results_dir, exist_ok=True)
+    
+    print(f"Results will be saved in: {results_dir}")
+
+    image_filenames = set(f for f in os.listdir(test_image_folder) if f.endswith('.tif'))
+    label_filenames = set(f for f in os.listdir(test_label_folder) if f.endswith('.tif'))
+
+    # Only keep files that are present in both folders
+    matched_filenames = sorted(image_filenames & label_filenames)
+
+    test_image_files = [os.path.join(test_image_folder, f) for f in matched_filenames]
+    test_label_files = [os.path.join(test_label_folder, f) for f in matched_filenames]
+
+    print(f"Found {len(test_image_files)} images and {len(test_label_files)} masks")
+
+    test_dataset = CellposeLazyDataset(test_image_files, test_label_files, settings, randomize=False, augment=False)
+
+    model = cp_models.CellposeModel(gpu=True, pretrained_model=settings['model_path'])
+
+    batch_size = settings['batch_size']
+    scores = []
+    names = []
+    time_ls = []
+    
+    files_to_process = len(test_image_folder)
+
+    for i in range(0, len(test_dataset), batch_size):
+        start = time.time()
+        batch = [test_dataset[j] for j in range(i, min(i + batch_size, len(test_dataset)))]
+        images, labels = zip(*batch)
+
+        masks_pred, flows, _ = model.eval(x=list(images),
+                                          channels=[0, 0],
+                                          normalize=False,
+                                          diameter=30,
+                                          flow_threshold=settings['FT'],
+                                          cellprob_threshold=settings['CP_probability'],
+                                          rescale=None,     
+                                          resample=True,
+                                          interp=True,
+                                          anisotropy=None,
+                                          min_size=5,         
+                                          augment=True,
+                                          tile=True,
+                                          tile_overlap=0.2,
+                                          bsize=224)
+        
+        n_objects_true_ls = []
+        n_objects_pred_ls = []
+        mean_area_true_ls = []
+        mean_area_pred_ls = []
+        tp_ls, fp_ls, fn_ls = [], [], []
+        precision_ls, recall_ls, f1_ls, accuracy_ls = [], [], [], []
+
+        for j, (img, lbl, pred, flow) in enumerate(zip(images, labels, masks_pred, flows)):
+            score = float(aggregated_jaccard_index([lbl], [pred]))
+            fname = os.path.basename(test_label_files[i + j])
+            scores.append(score)
+            names.append(fname)
+
+            # Label masks
+            lbl_lab = label(lbl)
+            pred_lab = label(pred)
+
+            # Count objects
+            n_true = lbl_lab.max()
+            n_pred = pred_lab.max()
+            n_objects_true_ls.append(n_true)
+            n_objects_pred_ls.append(n_pred)
+
+            # Mean object size (area)
+            area_true = [p.area for p in regionprops(lbl_lab)]
+            area_pred = [p.area for p in regionprops(pred_lab)]
+
+            mean_area_true = np.mean(area_true) if area_true else 0
+            mean_area_pred = np.mean(area_pred) if area_pred else 0
+            mean_area_true_ls.append(mean_area_true)
+            mean_area_pred_ls.append(mean_area_pred)
+            
+            # Compute object-level TP, FP, FN
+            ap, tp, fp, fn = average_precision([lbl], [pred], threshold=[0.5])
+            tp, fp, fn = int(tp[0, 0]), int(fp[0, 0]), int(fn[0, 0])
+            tp_ls.append(tp)
+            fp_ls.append(fp)
+            fn_ls.append(fn)
+
+            # Precision, Recall, F1, Accuracy
+            prec = tp / (tp + fp) if (tp + fp) > 0 else 0
+            rec = tp / (tp + fn) if (tp + fn) > 0 else 0
+            f1 = 2 * prec * rec / (prec + rec) if (prec + rec) > 0 else 0
+            acc = tp / (tp + fp + fn) if (tp + fp + fn) > 0 else 0
+
+            precision_ls.append(prec)
+            recall_ls.append(rec)
+            f1_ls.append(f1)
+            accuracy_ls.append(acc)
+
+            if settings['save']:
+                plot_cellpose_resilts(i, j, results_dir, img, lbl, pred, flow)
+
+            if settings['save']:
+                plot_cellpose_resilts(i,j,results_dir, img, lbl, pred, flow)
+                
+        stop = time.time()
+        duration = stop-start
+        files_processed = (i+1) * batch_size
+        time_ls.append(duration)
+        print_progress(files_processed, files_to_process, n_jobs=1, time_ls=None, batch_size=batch_size, operation_type="test custom cellpose model")
+
+    df_results = pd.DataFrame({
+        'label_image': names,
+        'Jaccard': scores,
+        'n_objects_true': n_objects_true_ls,
+        'n_objects_pred': n_objects_pred_ls,
+        'mean_area_true': mean_area_true_ls,
+        'mean_area_pred': mean_area_pred_ls,
+        'TP': tp_ls,
+        'FP': fp_ls,
+        'FN': fn_ls,
+        'Precision': precision_ls,
+        'Recall': recall_ls,
+        'F1': f1_ls,
+        'Accuracy': accuracy_ls
+    })
+    
+    df_results['n_error'] = abs(df_results['n_objects_pred'] - df_results['n_objects_true'])
+
+    print(f"Average true objects/image: {df_results['n_objects_true'].mean():.2f}")
+    print(f"Average predicted objects/image: {df_results['n_objects_pred'].mean():.2f}")
+    print(f"Mean object area (true): {df_results['mean_area_true'].mean():.2f} px")
+    print(f"Mean object area (pred): {df_results['mean_area_pred'].mean():.2f} px")
+    print(f"Average Jaccard score: {df_results['Jaccard'].mean():.4f}")
+    
+    print(f"Average Precision: {df_results['Precision'].mean():.3f}")
+    print(f"Average Recall: {df_results['Recall'].mean():.3f}")
+    print(f"Average F1-score: {df_results['F1'].mean():.3f}")
+    print(f"Average Accuracy: {df_results['Accuracy'].mean():.3f}")
+
+    display(df_results)
+
+    if settings['save']:
+        df_results.to_csv(os.path.join(results_dir, 'test_results.csv'), index=False)
+        
+def apply_cellpose_model(settings):
+    
+    from .settings import get_default_apply_cellpose_model_settings
+    from .utils import save_settings, print_progress
+    
+    def plot_cellpose_result(i, j, results_dir, img, pred, flow):
+        
+        from .plot import generate_mask_random_cmap  
+        
+        fig, axs = plt.subplots(1, 4, figsize=(16, 4), gridspec_kw={'wspace': 0.1, 'hspace': 0.1})
+        cmap_pred = generate_mask_random_cmap(pred)
+
+        axs[0].imshow(img, cmap='gray')
+        axs[0].set_title('Image')
+        axs[0].axis('off')
+
+        axs[1].imshow(pred, cmap=cmap_pred, interpolation='nearest')
+        axs[1].set_title('Predicted Mask')
+        axs[1].axis('off')
+        
+        axs[2].imshow(flow[2], cmap='gray')
+        axs[2].set_title('Cell Probability')
+        axs[2].axis('off')
+        
+        axs[3].imshow(flow[0], cmap='gray')
+        axs[3].set_title('Flows')
+        axs[3].axis('off')
+
+        save_path = os.path.join(results_dir, f"cellpose_result_{i + j:03d}.png")
+        plt.savefig(save_path, dpi=200, bbox_inches='tight')
+        plt.show()
+        plt.close(fig)
+        
+        
+    settings = get_default_apply_cellpose_model_settings(settings)
+    save_settings(settings, name='apply_cellpose_model')
+
+    image_folder = os.path.join(settings['src'])
+    results_dir = os.path.join(settings['src'], 'results')
+    os.makedirs(results_dir, exist_ok=True)
+    print(f"Results will be saved in: {results_dir}")
+
+    image_files = sorted([os.path.join(image_folder, f) for f in os.listdir(image_folder) if f.endswith('.tif')])
+    print(f"Found {len(image_files)} images")
+
+    dummy_labels = [image_files[0]] * len(image_files)
+    dataset = CellposeLazyDataset(image_files, dummy_labels, settings, randomize=False, augment=False)
+
+    model = cp_models.CellposeModel(gpu=True, pretrained_model=settings['model_path'])
+    batch_size = settings['batch_size']
+    measurements = []
+    
+    files_to_process = len(image_files)
+    time_ls = []
+
+    for i in range(0, len(dataset), batch_size):
+        start = time.time() 
+        batch = [dataset[j] for j in range(i, min(i + batch_size, len(dataset)))]
+        images, _ = zip(*batch)
+        
+        X = list(images)
+        
+        print(settings['CP_probability'])
+        masks_pred, flows, _ = model.eval(x=list(images),
+                                          channels=[0, 0],
+                                          normalize=False,
+                                          diameter=30,
+                                          flow_threshold=settings['FT'],
+                                          cellprob_threshold=settings['CP_probability'],
+                                          rescale=None,     
+                                          resample=True,
+                                          interp=True,
+                                          anisotropy=None,
+                                          min_size=5,         
+                                          augment=True,
+                                          tile=True,
+                                          tile_overlap=0.2,
+                                          bsize=224)
+        
+        for j, (img, pred, flow) in enumerate(zip(images, masks_pred, flows)):
+            fname = os.path.basename(image_files[i + j])
+
+            if settings.get('circularize', False):
+                h, w = pred.shape
+                Y, X = np.ogrid[:h, :w]
+                center_x, center_y = w / 2, h / 2
+                radius = min(center_x, center_y)
+                circular_mask = (X - center_x)**2 + (Y - center_y)**2 <= radius**2
+                pred = pred * circular_mask
+
+            if settings['save']:
+                plot_cellpose_result(i, j, results_dir, img, pred, flow)
+
+            props = regionprops(sklabel(pred))
+            for k, prop in enumerate(props):
+                measurements.append({
+                    'image': fname,
+                    'object_id': k + 1,
+                    'area': prop.area
+                })
+                
+        stop = time.time()            
+        duration = stop-start
+        files_processed = (i+1) * batch_size
+        time_ls.append(duration)
+        print_progress(files_processed, files_to_process, n_jobs=1, time_ls=None, batch_size=batch_size, operation_type="apply custom cellpose model")
+
+
+        # Write after each batch
+        df_measurements = pd.DataFrame(measurements)
+        df_measurements.to_csv(os.path.join(results_dir, 'measurements.csv'), index=False)
+        print("Saved object counts and areas to measurements.csv")
+
+        df_summary = df_measurements.groupby('image').agg(
+            object_count=('object_id', 'count'),
+            average_area=('area', 'mean')
+        ).reset_index()
+        df_summary.to_csv(os.path.join(results_dir, 'summary.csv'), index=False)
+        print("Saved object count and average area to summary.csv")
+
+def plot_cellpose_batch(images, labels):
+    from .plot import generate_mask_random_cmap
+
+    cmap_lbl = generate_mask_random_cmap(labels)
+    batch_size = len(images)
+    fig, axs = plt.subplots(2, batch_size, figsize=(4 * batch_size, 8))
+    for i in range(batch_size):
+        axs[0, i].imshow(images[i], cmap='gray')
+        axs[0, i].set_title(f'Image {i+1}')
+        axs[0, i].axis('off')
+        axs[1, i].imshow(labels[i], cmap=cmap_lbl, interpolation='nearest')
+        axs[1, i].set_title(f'Label {i+1}')
+        axs[1, i].axis('off')
+    plt.show()
+
+def analyze_percent_positive(settings):
+    from .io import _read_and_merge_data
+    from .utils import save_settings
+    from .settings import default_settings_analyze_percent_positive
+    
+    settings = default_settings_analyze_percent_positive(settings)
+    
+    def translate_well_in_df(csv_loc):
+        # Load and extract metadata
+        df = pd.read_csv(csv_loc)
+        df[['plateID', 'well']] = df['Renamed TIFF'].str.replace('.tif', '', regex=False).str.split('_', expand=True)[[0, 1]]
+        df['plate_well'] = df['plateID'] + '_' + df['well']
+
+        # Retain one row per plate_well
+        df_2 = df.drop_duplicates(subset='plate_well').copy()
+
+        # Translate well to row and column
+        df_2['rowID'] = 'r' + df_2['well'].str[0].map(lambda x: str(string.ascii_uppercase.index(x) + 1))
+        df_2['column_name'] = 'c' + df_2['well'].str[1:].astype(int).astype(str)
+
+        # Optional: add prcf ID (plate_row_column_field)
+        df_2['fieldID'] = 'f1'  # default or extract from filename if needed
+        df_2['prc'] = 'p' + df_2['plateID'].str.extract(r'(\d+)')[0] + '_' + df_2['rowID'] + '_' + df_2['column_name']
+
+        return df_2
+    
+    def annotate_and_summarize(df, value_col, condition_col, well_col, threshold, annotation_col='annotation'):
+        """
+        Annotate and summarize a DataFrame based on a threshold.
+
+        Parameters:
+        - df: pandas.DataFrame
+        - value_col: str, column name to apply threshold on
+        - condition_col: str, column name for experimental condition
+        - well_col: str, column name for wells
+        - threshold: float, threshold value for annotation
+        - annotation_col: str, name of the new annotation column
+
+        Returns:
+        - df: annotated DataFrame
+        - summary_df: DataFrame with counts and fractions per condition and well
+        """
+        # Annotate
+        df[annotation_col] = np.where(df[value_col] > threshold, 'above', 'below')
+
+        # Count per condition and well
+        count_df = df.groupby([condition_col, well_col, annotation_col]).size().unstack(fill_value=0)
+
+        # Calculate total and fractions
+        count_df['total'] = count_df.sum(axis=1)
+        count_df['fraction_above'] = count_df.get('above', 0) / count_df['total']
+        count_df['fraction_below'] = count_df.get('below', 0) / count_df['total']
+
+        return df, count_df.reset_index()
+    
+    save_settings(settings, name='analyze_percent_positive', show=False)
+    
+    df, _ = _read_and_merge_data(locs=[settings['src']+'/measurements/measurements.db'], 
+                             tables=settings['tables'], 
+                             verbose=True, 
+                             nuclei_limit=None, 
+                             pathogen_limit=None)
+
+    df['condition'] = 'none'
+    
+    if not settings['filter_1'] is None:
+        df = df[df[settings['filter_1'][0]]>settings['filter_1'][1]]
+    
+    condition_col = 'condition'
+    well_col = 'prc'
+    
+    df, count_df = annotate_and_summarize(df, settings['value_col'], condition_col, well_col, settings['threshold'], annotation_col='annotation')
+    count_df[['plateID', 'rowID', 'column_name']] = count_df['prc'].str.split('_', expand=True)
+    
+    csv_loc = os.path.join(settings['src'], 'rename_log.csv')
+    csv_out_loc = os.path.join(settings['src'], 'result.csv')
+    translate_df = translate_well_in_df(csv_loc)
+    
+    merged = pd.merge(count_df, translate_df, on=['rowID', 'column_name'], how='inner')
+
+    merged = merged[['plate_y', 'well', 'plate_well','fieldID','rowID','column_name','prc_x','Original File','Renamed TIFF','above','below','fraction_above','fraction_below']]
+    merged[[f'part{i}' for i in range(merged['Original File'].str.count('_').max() + 1)]] = merged['Original File'].str.split('_', expand=True)
+    merged.to_csv(csv_out_loc, index=False)
+    display(merged)
+    return merged
+
 def analyze_recruitment(settings):
     """
     Analyze recruitment data by grouping the DataFrame by well coordinates and plotting controls and recruitment data.
@@ -136,7 +678,7 @@ def analyze_recruitment(settings):
 
 def analyze_plaques(settings):
 
-    from .cellpose import identify_masks_finetune
+    from .spacr_cellpose import identify_masks_finetune
     from .settings import get_analyze_plaque_settings
     from .utils import save_settings, download_models
     from spacr import __file__ as spacr_path
@@ -198,147 +740,6 @@ def analyze_plaques(settings):
     
     print(f"Analysis completed and saved to database '{db_name}'.")
 
-def train_cellpose(settings):
-    
-    from .io import _load_normalized_images_and_labels, _load_images_and_labels
-    from .settings import get_train_cellpose_default_settings
-    from .utils import save_settings
-
-    settings = get_train_cellpose_default_settings(settings)
-
-    img_src = settings['img_src'] 
-    mask_src = os.path.join(img_src, 'masks')
-    test_img_src = settings['test_img_src']
-    test_mask_src = settings['test_mask_src']
-
-    if settings['resize']:
-        target_height = settings['width_height'][1]
-        target_width = settings['width_height'][0]
-
-    if settings['test']:
-        test_img_src = os.path.join(os.path.dirname(settings['img_src']), 'test')
-        test_mask_src = os.path.join(settings['test_img_src'], 'mask')
-
-    test_images, test_masks, test_image_names, test_mask_names = None,None,None,None
-    print(settings)
-
-    if settings['from_scratch']:
-        model_name=f"scratch_{settings['model_name']}_{settings['model_type']}_e{settings['n_epochs']}_X{target_width}_Y{target_height}.CP_model"
-    else:
-        if settings['resize']:
-            model_name=f"{settings['model_name']}_{settings['model_type']}_e{settings['n_epochs']}_X{target_width}_Y{target_height}.CP_model"
-        else:
-            model_name=f"{settings['model_name']}_{settings['model_type']}_e{settings['n_epochs']}.CP_model"
-
-    model_save_path = os.path.join(settings['mask_src'], 'models', 'cellpose_model')
-    print(model_save_path)
-    os.makedirs(model_save_path, exist_ok=True)
-
-    save_settings(settings, name=model_name)
-    
-    if settings['from_scratch']:
-        model = cp_models.CellposeModel(gpu=True, model_type=settings['model_type'], diam_mean=settings['diameter'], pretrained_model=None)
-    else:
-        model = cp_models.CellposeModel(gpu=True, model_type=settings['model_type'])
-        
-    if settings['normalize']:
-
-        image_files = [os.path.join(img_src, f) for f in os.listdir(img_src) if f.endswith('.tif')]
-        label_files = [os.path.join(mask_src, f) for f in os.listdir(mask_src) if f.endswith('.tif')]
-        images, masks, image_names, mask_names, orig_dims = _load_normalized_images_and_labels(image_files, 
-                                                                                               label_files, 
-                                                                                               settings['channels'], 
-                                                                                               settings['percentiles'],  
-                                                                                               settings['invert'], 
-                                                                                               settings['verbose'], 
-                                                                                               settings['remove_background'], 
-                                                                                               settings['background'], 
-                                                                                               settings['Signal_to_noise'], 
-                                                                                               settings['target_height'], 
-                                                                                               settings['target_width'])        
-        images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
-        
-        if settings['test']:
-            test_image_files = [os.path.join(test_img_src, f) for f in os.listdir(test_img_src) if f.endswith('.tif')]
-            test_label_files = [os.path.join(test_mask_src, f) for f in os.listdir(test_mask_src) if f.endswith('.tif')]
-            test_images, test_masks, test_image_names, test_mask_names = _load_normalized_images_and_labels(test_image_files, 
-                                                                                                            test_label_files, 
-                                                                                                            settings['channels'], 
-                                                                                                            settings['percentiles'],  
-                                                                                                            settings['invert'], 
-                                                                                                            settings['verbose'], 
-                                                                                                            settings['remove_background'], 
-                                                                                                            settings['background'], 
-                                                                                                            settings['Signal_to_noise'], 
-                                                                                                            settings['target_height'], 
-                                                                                                            settings['target_width'])
-            test_images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in test_images]
-            
-    else:
-        images, masks, image_names, mask_names = _load_images_and_labels(img_src, mask_src, settings['invert'])
-        images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
-        
-        if settings['test']:
-            test_images, test_masks, test_image_names, test_mask_names = _load_images_and_labels(test_img_src, 
-                                                                                                 test_mask_src, 
-                                                                                                 settings['invert'])
-            
-            test_images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in test_images]
-    
-    #if resize:
-    #    images, masks = resize_images_and_labels(images, masks, target_height, target_width, show_example=True)
-
-    if settings['model_type'] == 'cyto':
-        cp_channels = [0,1]
-    if settings['model_type'] == 'cyto2':
-        cp_channels = [0,2]
-    if settings['model_type'] == 'nucleus':
-        cp_channels = [0,0]
-    if settings['grayscale']:
-        cp_channels = [0,0]
-        images = [np.squeeze(img) if img.ndim == 3 and 1 in img.shape else img for img in images]
-    
-    masks = [np.squeeze(mask) if mask.ndim == 3 and 1 in mask.shape else mask for mask in masks]
-
-    print(f'image shape: {images[0].shape}, image type: images[0].shape mask shape: {masks[0].shape}, image type: masks[0].shape')
-    save_every = int(settings['n_epochs']/10)
-    if save_every < 10:
-        save_every = settings['n_epochs']
-
-    train_cp.train_seg(model.net,
-                    train_data=images,
-                    train_labels=masks,
-                    train_files=image_names,
-                    train_labels_files=mask_names,
-                    train_probs=None,
-                    test_data=test_images,
-                    test_labels=test_masks,
-                    test_files=test_image_names,
-                    test_labels_files=test_mask_names, 
-                    test_probs=None,
-                    load_files=True,
-                    batch_size=settings['batch_size'],
-                    learning_rate=settings['learning_rate'],
-                    n_epochs=settings['n_epochs'],
-                    weight_decay=settings['weight_decay'],
-                    momentum=0.9,
-                    SGD=False,
-                    channels=cp_channels,
-                    channel_axis=None,
-                    normalize=False, 
-                    compute_flows=False,
-                    save_path=model_save_path,
-                    save_every=save_every,
-                    nimg_per_epoch=None,
-                    nimg_test_per_epoch=None,
-                    rescale=settings['rescale'],
-                    #scale_range=None,
-                    #bsize=224,
-                    min_train_masks=1,
-                    model_name=settings['model_name'])
-
-    return print(f"Model saved at: {model_save_path}/{model_name}")
-
 def count_phenotypes(settings):
     from .io import _read_db
 
@@ -350,17 +751,17 @@ def count_phenotypes(settings):
     unique_values_count = df[settings['annotation_column']].nunique(dropna=True)
     print(f"Unique values in {settings['annotation_column']} (excluding NaN): {unique_values_count}")
 
-    # Count unique values in 'value' column, grouped by 'plate', 'row_name', 'column'
-    grouped_unique_count = df.groupby(['plate', 'row_name', 'column'])[settings['annotation_column']].nunique(dropna=True).reset_index(name='unique_count')
+    # Count unique values in 'value' column, grouped by 'plateID', 'rowID', 'columnID'
+    grouped_unique_count = df.groupby(['plateID', 'rowID', 'columnID'])[settings['annotation_column']].nunique(dropna=True).reset_index(name='unique_count')
     display(grouped_unique_count)
 
     save_path = os.path.join(settings['src'], 'phenotype_counts.csv')
 
     # Group by plate, row, and column, then count the occurrences of each unique value
-    grouped_counts = df.groupby(['plate', 'row_name', 'column', 'value']).size().reset_index(name='count')
+    grouped_counts = df.groupby(['plateID', 'rowID', 'columnID', 'value']).size().reset_index(name='count')
 
     # Pivot the DataFrame so that unique values are columns and their counts are in the rows
-    pivot_df = grouped_counts.pivot_table(index=['plate', 'row_name', 'column'], columns='value', values='count', fill_value=0)
+    pivot_df = grouped_counts.pivot_table(index=['plateID', 'rowID', 'columnID'], columns='value', values='count', fill_value=0)
 
     # Flatten the multi-level columns
     pivot_df.columns = [f"value_{int(col)}" for col in pivot_df.columns]
@@ -382,20 +783,20 @@ def count_phenotypes(settings):
 def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),'r2':(90,10),'r3':(80,20),'r4':(80,20),'r5':(70,30),'r6':(70,30),'r7':(60,40),'r8':(60,40),'r9':(50,50),'r10':(50,50),'r11':(40,60),'r12':(40,60),'r13':(30,70),'r14':(30,70),'r15':(20,80),'r16':(20,80)},
                             pc_grna='TGGT1_220950_1', nc_grna='TGGT1_233460_4', 
                             y_columns=['class_1_fraction', 'TGGT1_220950_1_fraction', 'nc_fraction'], 
-                            column='column', value='c3', plate=None, save_paths=None):
+                            column='columnID', value='c3', plate=None, save_paths=None):
 
     def calculate_well_score_fractions(df, class_columns='cv_predictions'):
-        if all(col in df.columns for col in ['plate', 'row_name', 'column']):
-            df['prc'] = df['plate'] + '_' + df['row_name'] + '_' + df['column']
+        if all(col in df.columns for col in ['plateID', 'rowID', 'columnID']):
+            df['prc'] = df['plateID'] + '_' + df['rowID'] + '_' + df['columnID']
         else:
-            raise ValueError("Cannot find 'plate', 'row_name', or 'column' in df.columns")
-        prc_summary = df.groupby(['plate', 'row_name', 'column', 'prc']).size().reset_index(name='total_rows')
-        well_counts = (df.groupby(['plate', 'row_name', 'column', 'prc', class_columns])
+            raise ValueError("Cannot find 'plateID', 'rowID', or 'columnID' in df.columns")
+        prc_summary = df.groupby(['plateID', 'rowID', 'columnID', 'prc']).size().reset_index(name='total_rows')
+        well_counts = (df.groupby(['plateID', 'rowID', 'columnID', 'prc', class_columns])
                        .size()
                        .unstack(fill_value=0)
                        .reset_index()
                        .rename(columns={0: 'class_0', 1: 'class_1'}))
-        summary_df = pd.merge(prc_summary, well_counts, on=['plate', 'row_name', 'column', 'prc'], how='left')
+        summary_df = pd.merge(prc_summary, well_counts, on=['plateID', 'rowID', 'columnID', 'prc'], how='left')
         summary_df['class_0_fraction'] = summary_df['class_0'] / summary_df['total_rows']
         summary_df['class_1_fraction'] = summary_df['class_1'] / summary_df['total_rows']
         return summary_df
@@ -490,8 +891,8 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
         return result
 
     def calculate_well_read_fraction(df, count_column='count'):
-        if all(col in df.columns for col in ['plate', 'row_name', 'column']):
-            df['prc'] = df['plate'] + '_' + df['row_name'] + '_' + df['column']
+        if all(col in df.columns for col in ['plateID', 'rowID', 'columnID']):
+            df['prc'] = df['plateID'] + '_' + df['rowID'] + '_' + df['columnID']
         else:
             raise ValueError("Cannot find plate, row or column in df.columns")
         grouped_df = df.groupby('prc')[count_column].sum().reset_index()
@@ -507,21 +908,17 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
             for i, reads_csv_temp in enumerate(reads_csv):
                 reads_df_temp = pd.read_csv(reads_csv_temp)
                 scores_df_temp = pd.read_csv(scores_csv[i])
-                reads_df_temp['plate'] = f"plate{i+1}"
-                scores_df_temp['plate'] = f"plate{i+1}"
+                reads_df_temp['plateID'] = f"plate{i+1}"
+                scores_df_temp['plateID'] = f"plate{i+1}"
                 
+                if 'column' in reads_df_temp.columns:
+                    reads_df_temp = reads_df_temp.rename(columns={'column': 'columnID'})
                 if 'column_name' in reads_df_temp.columns:
-                    reads_df_temp = reads_df_temp.rename(columns={'column_name': 'column'})
-                if 'column_name' in reads_df_temp.columns:
-                    reads_df_temp = reads_df_temp.rename(columns={'column_name': 'column'})
-                if 'column_name' in scores_df_temp.columns:
-                    scores_df_temp = scores_df_temp.rename(columns={'column_name': 'column'})
-                if 'column_name' in scores_df_temp.columns:
-                    scores_df_temp = scores_df_temp.rename(columns={'column_name': 'column'})
-                if 'row_name' in reads_df_temp.columns:
-                    reads_df_temp = reads_df_temp.rename(columns={'row_name': 'row_name'})
+                    reads_df_temp = reads_df_temp.rename(columns={'column_name': 'columnID'})
+                if 'row' in reads_df_temp.columns:
+                    reads_df_temp = reads_df_temp.rename(columns={'row_name': 'rowID'})
                 if 'row_name' in scores_df_temp.columns:
-                    scores_df_temp = scores_df_temp.rename(columns={'row_name': 'row_name'})
+                    scores_df_temp = scores_df_temp.rename(columns={'row_name': 'rowID'})
                     
                 reads_ls.append(reads_df_temp)
                 scores_ls.append(scores_df_temp)
@@ -535,8 +932,8 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
         reads_df = pd.read_csv(reads_csv)
         scores_df = pd.read_csv(scores_csv)
         if plate != None:
-            reads_df['plate'] = plate
-            scores_df['plate'] = plate
+            reads_df['plateID'] = plate
+            scores_df['plateID'] = plate
         
     reads_df = calculate_well_read_fraction(reads_df)
     scores_df = calculate_well_score_fractions(scores_df)
@@ -548,7 +945,7 @@ def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={'r1':(90,10),
     
     df_emp = pd.DataFrame([(key, val[0], val[1], val[0] / (val[0] + val[1]), val[1] / (val[0] + val[1])) for key, val in empirical_dict.items()],columns=['key', 'value1', 'value2', 'pc_fraction', 'nc_fraction'])
     
-    df = pd.merge(df, df_emp, left_on='row_name', right_on='key')
+    df = pd.merge(df, df_emp, left_on='rowID', right_on='key')
     
     if any in y_columns not in df.columns:
         print(f"columns in dataframe:")
@@ -620,7 +1017,7 @@ def interperate_vision_model(settings={}):
             else:
                 return None
 
-        from spacr.plot import spacrGraph
+        from .plot import spacrGraph
 
         df[name] = df['feature'].apply(lambda x: find_feature_class(x, feature_groups))
 
@@ -698,11 +1095,17 @@ def interperate_vision_model(settings={}):
         # Clean and align columns for merging
         df['object_label'] = df['object_label'].str.replace('o', '')
 
-        if 'row_name' not in scores_df.columns:
-            scores_df['row_name'] = scores_df['row']
+        if 'rowID' not in scores_df.columns:
+            if 'row' in scores_df.columns:
+                scores_df['rowID'] = scores_df['row']
+            if 'row_name' in scores_df.columns:
+                scores_df['rowID'] = scores_df['row_name']
 
-        if 'column_name' not in scores_df.columns:
-            scores_df['column_name'] = scores_df['col']
+        if 'columnID' not in scores_df.columns:
+            if 'column_name' in scores_df.columns:
+                scores_df['columnID'] = scores_df['column_name']
+            if 'column' in scores_df.columns:
+                scores_df['columnID'] = scores_df['column']
 
         if 'object_label' not in scores_df.columns:
             scores_df['object_label'] = scores_df['object']
@@ -714,14 +1117,14 @@ def interperate_vision_model(settings={}):
         scores_df['object_label'] = scores_df['object'].astype(str)
 
         # Ensure all join columns have the same data type in both DataFrames
-        df[['plate', 'row_name', 'column_name', 'field', 'object_label']] = df[['plate', 'row_name', 'column_name', 'field', 'object_label']].astype(str)
-        scores_df[['plate', 'row_name', 'column_name', 'field', 'object_label']] = scores_df[['plate', 'row_name', 'column_name', 'field', 'object_label']].astype(str)
+        df[['plateID', 'rowID', 'column_name', 'fieldID', 'object_label']] = df[['plateID', 'rowID', 'column_name', 'fieldID', 'object_label']].astype(str)
+        scores_df[['plateID', 'rowID', 'column_name', 'fieldID', 'object_label']] = scores_df[['plateID', 'rowID', 'column_name', 'fieldID', 'object_label']].astype(str)
 
         # Select only the necessary columns from scores_df for merging
-        scores_df = scores_df[['plate', 'row_name', 'column_name', 'field', 'object_label', settings['score_column']]]
+        scores_df = scores_df[['plateID', 'rowID', 'column_name', 'fieldID', 'object_label', settings['score_column']]]
 
         # Now merge DataFrames
-        merged_df = pd.merge(df, scores_df, on=['plate', 'row_name', 'column_name', 'field', 'object_label'], how='inner')
+        merged_df = pd.merge(df, scores_df, on=['plateID', 'rowID', 'column_name', 'fieldID', 'object_label'], how='inner')
 
         # Separate numerical features and the score column
         X = merged_df.select_dtypes(include='number').drop(columns=[settings['score_column']])
@@ -997,8 +1400,8 @@ def analyze_endodyogeny(settings):
     output['data'] = df
     
     
-    if settings['level'] == 'plate':
-        prc_column = 'plate'
+    if settings['level'] == 'plateID':
+        prc_column = 'plateID'
     else:
         prc_column = 'prc'
     
@@ -1144,28 +1547,28 @@ def generate_score_heatmap(settings):
     def group_cv_score(csv, plate=1, column='c3', data_column='pred'):
         
         df = pd.read_csv(csv)
-        if 'col' in df.columns:
-            df = df[df['col']==column]
+        if 'columnID' in df.columns:
+            df = df[df['columnID']==column]
         elif 'column' in df.columns:
-            df['col'] = df['column']
-            df = df[df['col']==column]
+            df['columnID'] = df['column']
+            df = df[df['columnID']==column]
         if not plate is None:
-            df['plate'] = f"plate{plate}"
-        grouped_df = df.groupby(['plate', 'row', 'col'])[data_column].mean().reset_index()
-        grouped_df['prc'] = grouped_df['plate'].astype(str) + '_' + grouped_df['row'].astype(str) + '_' + grouped_df['col'].astype(str)
+            df['plateID'] = f"plate{plate}"
+        grouped_df = df.groupby(['plateID', 'rowID', 'columnID'])[data_column].mean().reset_index()
+        grouped_df['prc'] = grouped_df['plateID'].astype(str) + '_' + grouped_df['rowID'].astype(str) + '_' + grouped_df['columnID'].astype(str)
         return grouped_df
 
     def calculate_fraction_mixed_condition(csv, plate=1, column='c3', control_sgrnas = ['TGGT1_220950_1', 'TGGT1_233460_4']):
         df = pd.read_csv(csv)  
         df = df[df['column_name']==column]
         if plate not in df.columns:
-            df['plate'] = f"plate{plate}"
+            df['plateID'] = f"plate{plate}"
         df = df[df['grna_name'].str.match(f'^{control_sgrnas[0]}$|^{control_sgrnas[1]}$')]
-        grouped_df = df.groupby(['plate', 'row_name', 'column_name'])['count'].sum().reset_index()
+        grouped_df = df.groupby(['plateID', 'rowID', 'columnID'])['count'].sum().reset_index()
         grouped_df = grouped_df.rename(columns={'count': 'total_count'})
-        merged_df = pd.merge(df, grouped_df, on=['plate', 'row_name', 'column_name'])
+        merged_df = pd.merge(df, grouped_df, on=['plateID', 'rowID', 'column_name'])
         merged_df['fraction'] = merged_df['count'] / merged_df['total_count']
-        merged_df['prc'] = merged_df['plate'].astype(str) + '_' + merged_df['row_name'].astype(str) + '_' + merged_df['column_name'].astype(str)
+        merged_df['prc'] = merged_df['plateID'].astype(str) + '_' + merged_df['rowID'].astype(str) + '_' + merged_df['column_name'].astype(str)
         return merged_df
 
     def plot_multi_channel_heatmap(df, column='c3', cmap='coolwarm'):
@@ -1177,17 +1580,17 @@ def generate_score_heatmap(settings):
         - column: Column to filter by (default is 'c3').
         """
         # Extract row number and convert to integer for sorting
-        df['row_num'] = df['row'].str.extract(r'(\d+)').astype(int)
+        df['row_num'] = df['rowID'].str.extract(r'(\d+)').astype(int)
 
         # Filter and sort by plate, row, and column
-        df = df[df['col'] == column]
-        df = df.sort_values(by=['plate', 'row_num', 'col'])
+        df = df[df['columnID'] == column]
+        df = df.sort_values(by=['plateID', 'row_num', 'columnID'])
 
         # Drop temporary 'row_num' column after sorting
         df = df.drop('row_num', axis=1)
 
         # Create a new column combining plate, row, and column for the index
-        df['plate_row_col'] = df['plate'] + '-' + df['row'] + '-' + df['col']
+        df['plate_row_col'] = df['plateID'] + '-' + df['rowID'] + '-' + df['columnID']
 
         # Set 'plate_row_col' as the index
         df.set_index('plate_row_col', inplace=True)
@@ -1244,11 +1647,11 @@ def generate_score_heatmap(settings):
         # Loop through all collected CSV files and process them
         for csv_file in ls:
             df = pd.read_csv(csv_file)  # Read CSV into DataFrame
-            df = df[df['col']==column]
+            df = df[df['columnID']==column]
             if not plate is None:
-                df['plate'] = f"plate{plate}"
-            # Group the data by 'plate', 'row', and 'col'
-            grouped_df = df.groupby(['plate', 'row', 'col'])[data_column].mean().reset_index()
+                df['plateID'] = f"plate{plate}"
+            # Group the data by 'plateID', 'rowID', and 'columnID'
+            grouped_df = df.groupby(['plateID', 'rowID', 'columnID'])[data_column].mean().reset_index()
             # Use the CSV filename to create a new column name
             folder_name = os.path.dirname(csv_file).replace(".csv", "")
             new_column_name = os.path.basename(f"{folder_name}_{data_column}")
@@ -1259,8 +1662,8 @@ def generate_score_heatmap(settings):
             if combined_df is None:
                 combined_df = grouped_df
             else:
-                combined_df = pd.merge(combined_df, grouped_df, on=['plate', 'row', 'col'], how='outer')
-        combined_df['prc'] = combined_df['plate'].astype(str) + '_' + combined_df['row'].astype(str) + '_' + combined_df['col'].astype(str)
+                combined_df = pd.merge(combined_df, grouped_df, on=['plateID', 'rowID', 'columnID'], how='outer')
+        combined_df['prc'] = combined_df['plateID'].astype(str) + '_' + combined_df['rowID'].astype(str) + '_' + combined_df['columnID'].astype(str)
         return combined_df
     
     def calculate_mae(df):
@@ -1282,16 +1685,16 @@ def generate_score_heatmap(settings):
         mae_df = pd.DataFrame(mae_data)
         return mae_df
 
-    result_df = combine_classification_scores(settings['folders'], settings['csv_name'], settings['data_column'], settings['plate'], settings['column'], )
-    df = calculate_fraction_mixed_condition(settings['csv'], settings['plate'], settings['column'], settings['control_sgrnas'])
+    result_df = combine_classification_scores(settings['folders'], settings['csv_name'], settings['data_column'], settings['plateID'], settings['columnID'], )
+    df = calculate_fraction_mixed_condition(settings['csv'], settings['plateID'], settings['columnID'], settings['control_sgrnas'])
     df = df[df['grna_name']==settings['fraction_grna']]
     fraction_df = df[['fraction', 'prc']]
     merged_df = pd.merge(fraction_df, result_df, on=['prc'])
-    cv_df = group_cv_score(settings['cv_csv'], settings['plate'], settings['column'], settings['data_column_cv'])
+    cv_df = group_cv_score(settings['cv_csv'], settings['plateID'], settings['columnID'], settings['data_column_cv'])
     cv_df = cv_df[[settings['data_column_cv'], 'prc']]
     merged_df = pd.merge(merged_df, cv_df, on=['prc'])
     
-    fig = plot_multi_channel_heatmap(merged_df, settings['column'], settings['cmap'])
+    fig = plot_multi_channel_heatmap(merged_df, settings['columnID'], settings['cmap'])
     if 'row_number' in merged_df.columns:
         merged_df = merged_df.drop('row_num', axis=1)
     mae_df = calculate_mae(merged_df)
@@ -1299,9 +1702,9 @@ def generate_score_heatmap(settings):
         mae_df = mae_df.drop('row_num', axis=1)
         
     if not settings['dst'] is None:
-        mae_dst = os.path.join(settings['dst'], f"mae_scores_comparison_plate_{settings['plate']}.csv")
-        merged_dst = os.path.join(settings['dst'], f"scores_comparison_plate_{settings['plate']}_data.csv")
-        heatmap_save = os.path.join(settings['dst'], f"scores_comparison_plate_{settings['plate']}.pdf")
+        mae_dst = os.path.join(settings['dst'], f"mae_scores_comparison_plate_{settings['plateID']}.csv")
+        merged_dst = os.path.join(settings['dst'], f"scores_comparison_plate_{settings['plateID']}_data.csv")
+        heatmap_save = os.path.join(settings['dst'], f"scores_comparison_plate_{settings['plateID']}.pdf")
         mae_df.to_csv(mae_dst, index=False)
         merged_df.to_csv(merged_dst, index=False)
         fig.savefig(heatmap_save, format='pdf', dpi=600, bbox_inches='tight')