celldetective 1.4.2__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

celldetective/gui/processes/track_cells.py

@@ -1,303 +0,0 @@
-from multiprocessing import Process
-import time
-from celldetective.io import auto_load_number_of_frames, _load_frames_to_measure, locate_labels
-from celldetective.utils import config_section_to_dict, _get_img_num_per_channel, \
-	_mask_intensity_measurements, remove_file_if_exists
-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.exp_dir,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"
-
-		else:
-			self.label_folder = f"labels_{self.mode}"
-			self.instruction_file = os.sep.join(["configs",f"tracking_instructions_{self.mode}.json"])
-			self.napari_name = f"napari_{self.mode}_trajectories.npy"
-			self.table_name = f"trajectories_{self.mode}.csv"			
-
-	def extract_experiment_parameters(self):
-
-		self.movie_prefix = config_section_to_dict(self.config, "MovieSettings")["movie_prefix"]
-		self.spatial_calibration = float(config_section_to_dict(self.config, "MovieSettings")["pxtoum"])
-		self.time_calibration = float(config_section_to_dict(self.config, "MovieSettings")["frametomin"])
-		self.len_movie = float(config_section_to_dict(self.config, "MovieSettings")["len_movie"])
-		self.shape_x = int(config_section_to_dict(self.config, "MovieSettings")["shape_x"])
-		self.shape_y = int(config_section_to_dict(self.config, "MovieSettings")["shape_y"])
-
-		self.channel_names, self.channel_indices = extract_experiment_channels(self.exp_dir)
-		self.nbr_channels = len(self.channel_names)
-
-	def locate_experiment_config(self):
-
-		parent1 = Path(self.pos).parent
-		self.exp_dir = parent1.parent
-		self.config = PurePath(self.exp_dir,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 = df.replace([np.inf, -np.inf], np.nan)
-
-		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'])}...")
-
-		remove_file_if_exists(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

@@ -1,270 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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")