celldetective 1.3.7.post1__py3-none-any.whl → 1.3.8__py3-none-any.whl

celldetective/gui/processes/track_cells.py

@@ -0,0 +1,298 @@
+from multiprocessing import Process
+import time
+import datetime
+import os
+import json
+from celldetective.io import auto_load_number_of_frames, _load_frames_to_measure, locate_labels
+from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, _mask_intensity_measurements
+from pathlib import Path, PurePath
+from glob import glob
+from tqdm import tqdm
+import numpy as np
+import gc
+import concurrent.futures
+import datetime
+import os
+import json
+from celldetective.io import interpret_tracking_configuration
+from celldetective.utils import extract_experiment_channels
+from celldetective.measure import drop_tonal_features, measure_features
+from celldetective.tracking import track
+import pandas as pd
+from natsort import natsorted
+from art import tprint
+
+
+class TrackingProcess(Process):
+
+	def __init__(self, queue=None, process_args=None, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+		
+		self.queue = queue
+
+		if process_args is not None:
+			for key, value in process_args.items():
+				setattr(self, key, value)
+
+
+		tprint("Track")
+		self.timestep_dataframes = []
+
+		# Experiment		
+		self.prepare_folders()
+
+		self.locate_experiment_config()
+		self.extract_experiment_parameters()
+		self.read_tracking_instructions()
+		self.detect_movie_and_labels()
+		self.detect_channels()
+
+		self.write_log()
+
+		if not self.btrack_option:
+			self.features = []
+			self.channel_names = None
+			self.haralick_options = None
+
+		self.sum_done = 0
+		self.t0 = time.time()
+
+	def read_tracking_instructions(self):
+
+		instr_path = PurePath(self.expfolder,Path(f"{self.instruction_file}"))
+		if os.path.exists(instr_path):
+			print(f"Tracking instructions for the {self.mode} population have been successfully loaded...")
+			with open(instr_path, 'r') as f:
+				self.instructions = json.load(f)
+			
+			self.btrack_config = interpret_tracking_configuration(self.instructions['btrack_config_path'])
+
+			if 'features' in self.instructions:
+				self.features = self.instructions['features']
+			else:
+				self.features = None
+			
+			if 'mask_channels' in self.instructions:
+				self.mask_channels = self.instructions['mask_channels']
+			else:
+				self.mask_channels = None
+			
+			if 'haralick_options' in self.instructions:
+				self.haralick_options = self.instructions['haralick_options']
+			else:
+				self.haralick_options = None
+
+			if 'post_processing_options' in self.instructions:
+				self.post_processing_options = self.instructions['post_processing_options']
+			else:
+				self.post_processing_options = None
+			
+			self.btrack_option = True
+			if 'btrack_option' in self.instructions:
+				self.btrack_option = self.instructions['btrack_option']
+			self.search_range = None
+			if 'search_range' in self.instructions:
+				self.search_range = self.instructions['search_range']
+			self.memory = None
+			if 'memory' in self.instructions:
+				self.memory = self.instructions['memory']
+		else:
+			print('Tracking instructions could not be located... Using a standard bTrack motion model instead...')
+			self.btrack_config = interpret_tracking_configuration(None)
+			self.features = None
+			self.mask_channels = None
+			self.haralick_options = None
+			self.post_processing_options = None
+			self.btrack_option = True
+			self.memory = None
+			self.search_range = None
+
+		if self.features is None:
+			self.features = []
+
+	def detect_channels(self):
+		self.img_num_channels = _get_img_num_per_channel(self.channel_indices, self.len_movie, self.nbr_channels)
+
+	def write_log(self):
+
+		features_log=f'features: {self.features}'
+		mask_channels_log=f'mask_channels: {self.mask_channels}'
+		haralick_option_log=f'haralick_options: {self.haralick_options}'
+		post_processing_option_log=f'post_processing_options: {self.post_processing_options}'
+		log_list=[features_log, mask_channels_log, haralick_option_log, post_processing_option_log]
+		log='\n'.join(log_list)
+
+		with open(self.pos+f'log_{self.mode}.txt', 'a') as f:
+			f.write(f'{datetime.datetime.now()} TRACK \n')
+			f.write(log+"\n")
+
+	def prepare_folders(self):
+
+		if not os.path.exists(self.pos+"output"):
+			os.mkdir(self.pos+"output")
+
+		if not os.path.exists(self.pos+os.sep.join(["output","tables"])):
+			os.mkdir(self.pos+os.sep.join(["output","tables"]))
+
+		if self.mode.lower()=="target" or self.mode.lower()=="targets":
+			self.label_folder = "labels_targets"
+			self.instruction_file = os.sep.join(["configs", "tracking_instructions_targets.json"])
+			self.napari_name = "napari_target_trajectories.npy"
+			self.table_name = "trajectories_targets.csv"
+
+		elif self.mode.lower()=="effector" or self.mode.lower()=="effectors":
+			self.label_folder = "labels_effectors"
+			self.instruction_file = os.sep.join(["configs","tracking_instructions_effectors.json"])
+			self.napari_name = "napari_effector_trajectories.npy"
+			self.table_name = "trajectories_effectors.csv"
+
+	def extract_experiment_parameters(self):
+
+		self.movie_prefix = ConfigSectionMap(self.config,"MovieSettings")["movie_prefix"]
+		self.spatial_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["pxtoum"])
+		self.time_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["frametomin"])
+		self.len_movie = float(ConfigSectionMap(self.config,"MovieSettings")["len_movie"])
+		self.shape_x = int(ConfigSectionMap(self.config,"MovieSettings")["shape_x"])
+		self.shape_y = int(ConfigSectionMap(self.config,"MovieSettings")["shape_y"])
+
+		self.channel_names, self.channel_indices = extract_experiment_channels(self.config)
+		self.nbr_channels = len(self.channel_names)
+
+	def locate_experiment_config(self):
+
+		parent1 = Path(self.pos).parent
+		self.expfolder = parent1.parent
+		self.config = PurePath(self.expfolder,Path("config.ini"))
+
+		if not os.path.exists(self.config):
+			print('The configuration file for the experiment was not found...')
+			self.abort_process()
+
+	def detect_movie_and_labels(self):
+
+		self.label_path = natsorted(glob(self.pos+f"{self.label_folder}"+os.sep+"*.tif"))
+		if len(self.label_path)>0:
+			print(f"Found {len(self.label_path)} segmented frames...")
+		else:
+			print(f"No segmented frames have been found. Please run segmentation first. Abort...")
+			self.abort_process()
+
+		try:
+			self.file = glob(self.pos+f"movie/{self.movie_prefix}*.tif")[0]
+		except IndexError:
+			self.file = None
+			self.haralick_option = None
+			self.features = drop_tonal_features(self.features)
+			print('Movie could not be found. Check the prefix.')
+
+		len_movie_auto = auto_load_number_of_frames(self.file)
+		if len_movie_auto is not None:
+			self.len_movie = len_movie_auto
+
+	def parallel_job(self, indices):
+
+		props = []
+
+		try:
+
+			for t in tqdm(indices,desc="frame"):
+				
+				# Load channels at time t
+				img = _load_frames_to_measure(self.file, indices=self.img_num_channels[:,t])
+				lbl = locate_labels(self.pos, population=self.mode, frames=t)
+				if lbl is None:
+					continue
+
+				df_props = measure_features(img, lbl, features = self.features+['centroid'], border_dist=None, 
+												channels=self.channel_names, haralick_options=self.haralick_options, verbose=False)
+				df_props.rename(columns={'centroid-1': 'x', 'centroid-0': 'y'},inplace=True)
+				df_props['t'] = int(t)
+
+				props.append(df_props)
+
+				self.sum_done+=1/self.len_movie*50
+				mean_exec_per_step = (time.time() - self.t0) / (self.sum_done*self.len_movie / 50 + 1)
+				pred_time = (self.len_movie - (self.sum_done*self.len_movie / 50 + 1)) * mean_exec_per_step + 30
+				self.queue.put([self.sum_done, pred_time])
+				
+
+		except Exception as e:
+			print(e)
+
+		return props
+
+	def run(self):
+
+		self.indices = list(range(self.img_num_channels.shape[1]))
+		chunks = np.array_split(self.indices, self.n_threads)
+
+		self.timestep_dataframes = []
+		with concurrent.futures.ThreadPoolExecutor(max_workers=self.n_threads) as executor:
+			results = executor.map(self.parallel_job, chunks)
+			try:
+				for i,return_value in enumerate(results):
+					print(f'Thread {i} completed...')
+					#print(f"Thread {i} output check: ",return_value)
+					self.timestep_dataframes.extend(return_value)
+			except Exception as e:
+				print("Exception: ", e)
+
+		print('Features successfully measured...')
+
+		df = pd.concat(self.timestep_dataframes)	
+		df.reset_index(inplace=True, drop=True)
+		df = _mask_intensity_measurements(df, self.mask_channels)
+
+		# do tracking
+		if self.btrack_option:
+			tracker = 'bTrack'
+		else:
+			tracker = 'trackpy'
+
+		# do tracking
+		trajectories, napari_data = track(None,
+							configuration=self.btrack_config,
+							objects=df, 
+							spatial_calibration=self.spatial_calibration, 
+							channel_names=self.channel_names,
+							return_napari_data=True,
+				  			optimizer_options = {'tm_lim': int(12e4)}, 
+				  			track_kwargs={'step_size': 100}, 
+				  			clean_trajectories_kwargs=self.post_processing_options, 
+				  			volume=(self.shape_x, self.shape_y),
+				  			btrack_option=self.btrack_option, 
+				  			search_range=self.search_range,
+				  			memory=self.memory,
+				  			)
+		print(f"Tracking successfully performed...")
+
+		# out trajectory table, create POSITION_X_um, POSITION_Y_um, TIME_min (new ones)
+		# Save napari data
+		np.save(self.pos+os.sep.join(['output', 'tables', self.napari_name]), napari_data, allow_pickle=True)
+
+		trajectories.to_csv(self.pos+os.sep.join(['output', 'tables', self.table_name]), index=False)
+		print(f"Trajectory table successfully exported in {os.sep.join(['output', 'tables'])}...")
+
+		if os.path.exists(self.pos+os.sep.join(['output', 'tables', self.table_name.replace('.csv','.pkl')])):
+			os.remove(self.pos+os.sep.join(['output', 'tables', self.table_name.replace('.csv','.pkl')]))
+
+		del trajectories; del napari_data;
+		gc.collect()		
+		
+		# Send end signal
+		self.queue.put([100, 0])
+		time.sleep(1)
+		
+		self.queue.put("finished")
+		self.queue.close()
+
+	def end_process(self):
+
+		self.terminate()
+		self.queue.put("finished")
+
+	def abort_process(self):
+		
+		self.terminate()
+		self.queue.put("error")

celldetective/gui/processes/train_segmentation_model.py

@@ -0,0 +1,270 @@
+from multiprocessing import Process
+import time
+import os
+import shutil
+from glob import glob
+import json
+from tqdm import tqdm
+import numpy as np
+import random
+
+from celldetective.utils import load_image_dataset, augmenter, interpolate_nan
+from celldetective.io import normalize_multichannel
+from stardist import fill_label_holes
+from art import tprint
+from distutils.dir_util import copy_tree
+from csbdeep.utils import save_json
+
+
+class TrainSegModelProcess(Process):
+
+	def __init__(self, queue=None, process_args=None, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+		
+		self.queue = queue
+
+		if process_args is not None:
+			for key, value in process_args.items():
+				setattr(self, key, value)
+
+		tprint("Train segmentation")
+		self.read_instructions()
+		self.extract_training_params()
+		self.load_dataset()
+		self.split_test_train()
+
+		self.sum_done = 0
+		self.t0 = time.time()
+
+	def read_instructions(self):
+
+		if os.path.exists(self.instructions):
+			with open(self.instructions, 'r') as f:
+				self.training_instructions = json.load(f)
+		else:
+			print('Training instructions could not be found. Abort.')
+			self.abort_process()
+
+	def run(self):
+
+		if self.model_type=="cellpose":
+			self.train_cellpose_model()
+		elif self.model_type=="stardist":
+			self.train_stardist_model()
+
+		self.queue.put("finished")
+		self.queue.close()
+
+	def train_stardist_model(self):
+
+		from stardist import calculate_extents, gputools_available
+		from stardist.models import Config2D, StarDist2D
+		
+		n_rays = 32
+		print(gputools_available())
+		
+		n_channel = self.X_trn[0].shape[-1]
+		
+		# Predict on subsampled grid for increased efficiency and larger field of view
+		grid = (2,2)
+		conf = Config2D(
+			n_rays       = n_rays,
+			grid         = grid,
+			use_gpu      = self.use_gpu,
+			n_channel_in = n_channel,
+			train_learning_rate = self.learning_rate,
+			train_patch_size = (256,256),
+			train_epochs = self.epochs,
+			train_reduce_lr = {'factor': 0.1, 'patience': 30, 'min_delta': 0},
+			train_batch_size = self.batch_size,
+			train_steps_per_epoch = int(self.augmentation_factor*len(self.X_trn)),
+		)
+		
+		if self.use_gpu:
+			from csbdeep.utils.tf import limit_gpu_memory
+			limit_gpu_memory(None, allow_growth=True)
+
+		if self.pretrained is None:
+			model = StarDist2D(conf, name=self.model_name, basedir=self.target_directory)
+		else:
+			os.rename(self.instructions, os.sep.join([self.target_directory, self.model_name, 'temp.json']))
+			copy_tree(self.pretrained, os.sep.join([self.target_directory, self.model_name]))
+			
+			if os.path.exists(os.sep.join([self.target_directory, self.model_name, 'training_instructions.json'])):
+				os.remove(os.sep.join([self.target_directory, self.model_name, 'training_instructions.json']))
+			if os.path.exists(os.sep.join([self.target_directory, self.model_name, 'config_input.json'])):
+				os.remove(os.sep.join([self.target_directory, self.model_name, 'config_input.json']))
+			if os.path.exists(os.sep.join([self.target_directory, self.model_name, 'logs'+os.sep])):
+				shutil.rmtree(os.sep.join([self.target_directory, self.model_name, 'logs']))
+			os.rename(os.sep.join([self.target_directory, self.model_name, 'temp.json']),os.sep.join([self.target_directory, self.model_name, 'training_instructions.json']))
+
+			#shutil.copytree(pretrained, os.sep.join([target_directory, model_name]))
+			model = StarDist2D(None, name=self.model_name, basedir=self.target_directory)
+			model.config.train_epochs = self.epochs
+			model.config.train_batch_size = min(len(self.X_trn),self.batch_size)
+			model.config.train_learning_rate = self.learning_rate # perf seems bad if lr is changed in transfer
+			model.config.use_gpu = self.use_gpu
+			model.config.train_reduce_lr = {'factor': 0.1, 'patience': 10, 'min_delta': 0}
+			print(f'{model.config=}')
+
+			save_json(vars(model.config), os.sep.join([self.target_directory, self.model_name, 'config.json']))
+
+		median_size = calculate_extents(list(self.Y_trn), np.mean)
+		fov = np.array(model._axes_tile_overlap('YX'))
+		print(f"median object size:      {median_size}")
+		print(f"network field of view :  {fov}")
+		if any(median_size > fov):
+			print("WARNING: median object size larger than field of view of the neural network.")
+
+		if self.augmentation_factor==1.0:
+			model.train(self.X_trn, self.Y_trn, validation_data=(self.X_val,self.Y_val))
+		else:
+			model.train(self.X_trn, self.Y_trn, validation_data=(self.X_val,self.Y_val), augmenter=augmenter)
+		model.optimize_thresholds(self.X_val,self.Y_val)
+
+		config_inputs = {"channels": self.target_channels, 'normalization_percentile': self.normalization_percentile,
+		'normalization_clip': self.normalization_clip, 'normalization_values': self.normalization_values, 
+		'model_type': 'stardist', 'spatial_calibration': self.spatial_calibration, 'dataset': {'train': self.files_train, 'validation': self.files_val}}
+
+		json_input_config = json.dumps(config_inputs, indent=4)
+		with open(os.sep.join([self.target_directory, self.model_name, "config_input.json"]), "w") as outfile:
+			outfile.write(json_input_config)
+
+	def train_cellpose_model(self):
+
+		# do augmentation in place
+		X_aug = []; Y_aug = [];
+		n_val = max(1, int(round(self.augmentation_factor * len(self.X_trn))))
+		indices = random.choices(list(np.arange(len(self.X_trn))), k=n_val)
+		print('Performing image augmentation pre-training...')
+		for i in tqdm(indices):
+			x_aug,y_aug = augmenter(self.X_trn[i], self.Y_trn[i])
+			X_aug.append(x_aug)
+			Y_aug.append(y_aug)
+		
+		# Channel axis in front for cellpose
+		X_aug = [np.moveaxis(x,-1,0) for x in X_aug]
+		self.X_val = [np.moveaxis(x,-1,0) for x in self.X_val]
+		print('number of augmented images: %3d' % len(X_aug))
+
+		from cellpose.models import CellposeModel
+		from cellpose.io import logger_setup
+		import torch
+		
+		if not self.use_gpu:
+			print('Using CPU for training...')
+			device = torch.device("cpu")
+		else:
+			print('Using GPU for training...')
+			
+		logger, log_file = logger_setup()
+		print(f'Pretrained model: ', self.pretrained)
+		if self.pretrained is not None:
+			pretrained_path = os.sep.join([self.pretrained,os.path.split(self.pretrained)[-1]])
+		else:
+			pretrained_path = self.pretrained
+		
+		model = CellposeModel(gpu=self.use_gpu, model_type=None, pretrained_model=pretrained_path, diam_mean=30.0, nchan=X_aug[0].shape[0],) 
+		model.train(train_data=X_aug, train_labels=Y_aug, normalize=False, channels=None, batch_size=self.batch_size,
+					min_train_masks=1,save_path=self.target_directory+os.sep+self.model_name,n_epochs=self.epochs, model_name=self.model_name, learning_rate=self.learning_rate, test_data = self.X_val, test_labels=self.Y_val)
+
+		file_to_move = glob(os.sep.join([self.target_directory, self.model_name, 'models','*']))[0]
+		shutil.move(file_to_move, os.sep.join([self.target_directory, self.model_name,''])+os.path.split(file_to_move)[-1])
+		os.rmdir(os.sep.join([self.target_directory, self.model_name, 'models']))
+
+		diameter = model.diam_labels
+
+		if self.pretrained is not None and os.path.split(self.pretrained)[-1]=='CP_nuclei':
+			standard_diameter = 17.0
+		else:
+			standard_diameter = 30.0
+
+		input_spatial_calibration = self.spatial_calibration #*diameter / standard_diameter
+
+		config_inputs = {"channels": self.target_channels, "diameter": standard_diameter, 'cellprob_threshold': 0., 'flow_threshold': 0.4,
+		'normalization_percentile': self.normalization_percentile, 'normalization_clip': self.normalization_clip,
+		'normalization_values': self.normalization_values, 'model_type': 'cellpose',
+		'spatial_calibration': input_spatial_calibration, 'dataset': {'train': self.files_train, 'validation': self.files_val}}
+		json_input_config = json.dumps(config_inputs, indent=4)
+		with open(os.sep.join([self.target_directory, self.model_name, "config_input.json"]), "w") as outfile:
+			outfile.write(json_input_config)
+
+
+	def split_test_train(self):
+
+		if not len(self.X) > 1:
+			print("Not enough training data")
+			self.abort_process()
+
+		rng = np.random.RandomState()
+		ind = rng.permutation(len(self.X))
+		n_val = max(1, int(round(self.validation_split * len(ind))))
+		ind_train, ind_val = ind[:-n_val], ind[-n_val:]
+		self.X_val, self.Y_val = [self.X[i] for i in ind_val]  , [self.Y[i] for i in ind_val]
+		self.X_trn, self.Y_trn = [self.X[i] for i in ind_train], [self.Y[i] for i in ind_train]
+
+		self.files_train = [self.filenames[i] for i in ind_train]
+		self.files_val = [self.filenames[i] for i in ind_val]
+
+		print('number of images: %3d' % len(self.X))
+		print('- training:       %3d' % len(self.X_trn))
+		print('- validation:     %3d' % len(self.X_val))
+
+	def extract_training_params(self):
+
+		self.model_name = self.training_instructions['model_name']
+		self.target_directory = self.training_instructions['target_directory']
+		self.model_type = self.training_instructions['model_type']
+		self.pretrained = self.training_instructions['pretrained']
+
+		self.datasets = self.training_instructions['ds']
+
+		self.target_channels = self.training_instructions['channel_option']
+		self.normalization_percentile = self.training_instructions['normalization_percentile']
+		self.normalization_clip = self.training_instructions['normalization_clip']
+		self.normalization_values = self.training_instructions['normalization_values']
+		self.spatial_calibration = self.training_instructions['spatial_calibration']
+
+		self.validation_split = self.training_instructions['validation_split']
+		self.augmentation_factor = self.training_instructions['augmentation_factor']
+
+		self.learning_rate = self.training_instructions['learning_rate']
+		self.epochs = self.training_instructions['epochs']
+		self.batch_size = self.training_instructions['batch_size']
+
+	def load_dataset(self):
+
+		print(f'Datasets: {self.datasets}')
+		self.X,self.Y,self.filenames = load_image_dataset(self.datasets, self.target_channels, train_spatial_calibration=self.spatial_calibration,
+								mask_suffix='labelled')
+		print('Dataset loaded...')
+
+		self.values = []
+		self.percentiles = []
+		for k in range(len(self.normalization_percentile)):
+			if self.normalization_percentile[k]:
+				self.percentiles.append(self.normalization_values[k])
+				self.values.append(None)
+			else:
+				self.percentiles.append(None)
+				self.values.append(self.normalization_values[k])
+
+		self.X = [normalize_multichannel(x, **{"percentiles": self.percentiles, 'values': self.values, 'clip': self.normalization_clip}) for x in self.X]
+
+		for k in range(len(self.X)):
+			x = self.X[k].copy()
+			x_interp = np.moveaxis([interpolate_nan(x[:,:,c].copy()) for c in range(x.shape[-1])],0,-1)
+			self.X[k] = x_interp
+
+		self.Y = [fill_label_holes(y) for y in tqdm(self.Y)]
+
+	def end_process(self):
+
+		self.terminate()
+		self.queue.put("finished")
+
+	def abort_process(self):
+		
+		self.terminate()
+		self.queue.put("error")

celldetective/gui/processes/train_signal_model.py

@@ -0,0 +1,108 @@
+from multiprocessing import Process
+import time
+import os
+import json
+from glob import glob
+import numpy as np
+from art import tprint
+from celldetective.signals import SignalDetectionModel
+from celldetective.io import locate_signal_model
+
+
+class TrainSignalModelProcess(Process):
+
+	def __init__(self, queue=None, process_args=None, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+		
+		self.queue = queue
+
+		if process_args is not None:
+			for key, value in process_args.items():
+				setattr(self, key, value)
+
+		tprint("Train segmentation")
+		self.read_instructions()
+		self.extract_training_params()
+
+
+		self.sum_done = 0
+		self.t0 = time.time()
+
+	def read_instructions(self):
+
+		if os.path.exists(self.instructions):
+			with open(self.instructions, 'r') as f:
+				self.training_instructions = json.load(f)
+		else:
+			print('Training instructions could not be found. Abort.')
+			self.abort_process()
+
+		all_classes = []
+		for d in self.training_instructions["ds"]:
+			datasets = glob(d+os.sep+"*.npy")
+			for dd in datasets:
+				data = np.load(dd, allow_pickle=True)
+				classes = np.unique([ddd["class"] for ddd in data])
+				all_classes.extend(classes)
+		all_classes = np.unique(all_classes)
+		n_classes = len(all_classes)
+
+		self.model_params = {k:self.training_instructions[k] for k in ('pretrained', 'model_signal_length', 'channel_option', 'n_channels', 'label') if k in self.training_instructions}
+		self.model_params.update({'n_classes': n_classes})
+		self.train_params = {k:self.training_instructions[k] for k in ('model_name', 'target_directory', 'channel_option','recompile_pretrained', 'test_split', 'augment', 'epochs', 'learning_rate', 'batch_size', 'validation_split','normalization_percentile','normalization_values','normalization_clip') if k in self.training_instructions}
+
+	def neighborhood_postprocessing(self):
+
+		# if neighborhood of interest in training instructions, write it in config!
+		if 'neighborhood_of_interest' in self.training_instructions:
+			if self.training_instructions['neighborhood_of_interest'] is not None:
+				
+				model_path = locate_signal_model(self.training_instructions['model_name'], path=None, pairs=True)
+				complete_path = model_path #+model
+				complete_path = rf"{complete_path}"
+				model_config_path = os.sep.join([complete_path,'config_input.json'])
+				model_config_path = rf"{model_config_path}"
+
+				f = open(model_config_path)
+				config = json.load(f)
+				config.update({'neighborhood_of_interest': self.training_instructions['neighborhood_of_interest'], 'reference_population': self.training_instructions['reference_population'], 'neighbor_population': self.training_instructions['neighbor_population']})
+				json_string = json.dumps(config)
+				with open(model_config_path, 'w') as outfile:
+					outfile.write(json_string)
+
+	def run(self):
+
+		model = SignalDetectionModel(**self.model_params)
+		model.fit_from_directory(self.training_instructions['ds'], **self.train_params)
+		self.neighborhood_postprocessing()
+		self.queue.put("finished")
+		self.queue.close()
+
+
+	def extract_training_params(self):
+
+		self.training_instructions.update({'n_channels': len(self.training_instructions['channel_option'])})
+		if self.training_instructions['augmentation_factor']>1.0:
+			self.training_instructions.update({'augment': True})
+		else:
+			self.training_instructions.update({'augment': False})
+		self.training_instructions.update({'test_split': 0.})
+
+
+	def end_process(self):
+		
+		# self.terminate()
+
+		# if self.model_type=="stardist":
+		# 	from stardist.models import StarDist2D
+		# 	self.model = StarDist2D(None, name=self.model_name, basedir=self.target_directory)
+		# 	self.model.optimize_thresholds(self.X_val,self.Y_val)
+
+		self.terminate()
+		self.queue.put("finished")
+
+	def abort_process(self):
+		
+		self.terminate()
+		self.queue.put("error")