From c5b72bec26abae1236ae0183e6a494c8f2eaa077 Mon Sep 17 00:00:00 2001 From: "a.ott" Date: Tue, 28 Jul 2020 10:54:02 +0200 Subject: [PATCH] code clean up --- Fitter.py | 140 +++----------------------------------- run_Fitter.py | 33 +++++---- tests/old_fit_routines.py | 127 ---------------------------------- 3 files changed, 28 insertions(+), 272 deletions(-) delete mode 100644 tests/old_fit_routines.py diff --git a/Fitter.py b/Fitter.py index b10cc17..9a2d67a 100644 --- a/Fitter.py +++ b/Fitter.py @@ -16,13 +16,9 @@ import matplotlib.pyplot as plt class Fitter: - def __init__(self, params=None): - if params is None: - self.base_model = LifacNoiseModel({"step_size": 0.00005}) - else: - self.base_model = LifacNoiseModel(params) - if "step_size" not in params: - self.base_model.set_variable("step_size", 0.00005) + def __init__(self): + + self.base_model = LifacNoiseModel({"step_size": 0.00005}) self.best_parameters_found = [] self.smallest_error = np.inf @@ -57,8 +53,6 @@ class Fitter: self.errors = [] - # self.tau_a = 0 - # counts how often the cost_function was called self.counter = 0 @@ -115,7 +109,7 @@ class Fitter: self.set_data_reference_values(data) return fit_routine_func(start_parameters) - def fit_routine_1(self, start_parameters): + def fit_routine(self, start_parameters, error_weights=None): self.counter = 0 # fit only v_offset, mem_tau, input_scaling, dend_tau @@ -125,8 +119,11 @@ class Fitter: initial_simplex = create_init_simples(x0, search_scale=3) # error_list = [error_bf, error_vs, error_sc, error_cv, error_bursty, - # error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope_at_straight, error_f0_curve] - error_weights = (1, 2, 2, 2, 2, 1, 1, 1, 0, 1) + # error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope_at_straight, error_f0_curve] + + if error_weights is None: + error_weights = (1, 2, 2, 2, 2, 1, 1, 1, 0, 1) + fmin = minimize(fun=self.cost_function_all, args=(error_weights,), x0=x0, method="Nelder-Mead", options={"initial_simplex": initial_simplex, "xatol": 0.001, "maxfev": 600, "maxiter": 400}) @@ -167,125 +164,6 @@ class Fitter: self.best_parameters_found = X return sum(error_list) - def cost_function_without_ref_period(self, X, error_weights=None): - self.base_model.set_variable("mem_tau", X[0]) - self.base_model.set_variable("noise_strength", X[1]) - self.base_model.set_variable("input_scaling", X[2]) - self.base_model.set_variable("tau_a", X[3]) - self.base_model.set_variable("delta_a", X[4]) - self.base_model.set_variable("dend_tau", X[5]) - - base_stimulus = SinusoidalStepStimulus(self.eod_freq, 0) - # find right v-offset - test_model = self.base_model.get_model_copy() - test_model.set_variable("noise_strength", 0) - v_offset = test_model.find_v_offset(self.baseline_freq, base_stimulus) - self.base_model.set_variable("v_offset", v_offset) - - # [error_bf, error_vs, error_sc, error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope] - error_list = self.calculate_errors(error_weights) - return sum(error_list) - - def cost_function_all_without_noise(self, X, error_weights=None): - self.base_model.set_variable("mem_tau", X[0]) - self.base_model.set_variable("input_scaling", X[1]) - self.base_model.set_variable("tau_a", X[2]) - self.base_model.set_variable("delta_a", X[3]) - self.base_model.set_variable("dend_tau", X[4]) - self.base_model.set_variable("noise_strength", 0) - - base_stimulus = SinusoidalStepStimulus(self.eod_freq, 0) - # find right v-offset - test_model = self.base_model.get_model_copy() - test_model.set_variable("noise_strength", 0) - v_offset = test_model.find_v_offset(self.baseline_freq, base_stimulus) - self.base_model.set_variable("v_offset", v_offset) - - # [error_bf, error_vs, error_sc, error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope] - error_list = self.calculate_errors(error_weights) - - return sum(error_list) - - def cost_function_only_adaption(self, X, error_weights=None): - self.base_model.set_variable("mem_tau", X[0]) - self.base_model.set_variable("input_scaling", X[1]) - self.base_model.set_variable("delta_a", X[2]) - self.base_model.set_variable("dend_tau", X[3]) - - base_stimulus = SinusoidalStepStimulus(self.eod_freq, 0) - # find right v-offset - test_model = self.base_model.get_model_copy() - test_model.set_variable("noise_strength", 0) - v_offset = test_model.find_v_offset(self.baseline_freq, base_stimulus) - self.base_model.set_variable("v_offset", v_offset) - # [error_bf, error_vs, error_sc, error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope] - error_list = self.calculate_errors(error_weights) - - return sum(error_list) - - def cost_function_with_fixed_adaption_tau(self, X, tau_a, error_weights=None): - # set model parameters: - model = self.base_model - model.set_variable("mem_tau", X[0]) - model.set_variable("noise_strength", X[1]) - model.set_variable("input_scaling", X[2]) - model.set_variable("delta_a", X[3]) - model.set_variable("dend_tau", X[4]) - model.set_variable("tau_a", tau_a) - - base_stimulus = SinusoidalStepStimulus(self.eod_freq, 0) - # find right v-offset - test_model = model.get_model_copy() - test_model.set_variable("noise_strength", 0) - v_offset = test_model.find_v_offset(self.baseline_freq, base_stimulus) - model.set_variable("v_offset", v_offset) - - error_list = self.calculate_errors(error_weights) - - return sum(error_list) - - def cost_function_with_fixed_adaption_with_dend_tau_no_noise(self, X, tau_a, delta_a, error_weights=None): - # set model parameters: - model = self.base_model - model.set_variable("mem_tau", X[0]) - model.set_variable("input_scaling", X[1]) - model.set_variable("dend_tau", X[2]) - model.set_variable("tau_a", tau_a) - model.set_variable("delta_a", delta_a) - model.set_variable("noise_strength", 0) - - base_stimulus = SinusoidalStepStimulus(self.eod_freq, 0) - # find right v-offset - test_model = model.get_model_copy() - test_model.set_variable("noise_strength", 0) - v_offset = test_model.find_v_offset(self.baseline_freq, base_stimulus) - model.set_variable("v_offset", v_offset) - - error_list = self.calculate_errors(error_weights) - - return sum(error_list) - - def cost_function_with_fixed_adaption_with_dend_tau(self, X, tau_a, delta_a, error_weights=None): - # set model parameters: - model = self.base_model - model.set_variable("mem_tau", X[0]) - model.set_variable("noise_strength", X[1]) - model.set_variable("input_scaling", X[2]) - model.set_variable("dend_tau", X[3]) - model.set_variable("tau_a", tau_a) - model.set_variable("delta_a", delta_a) - - base_stimulus = SinusoidalStepStimulus(self.eod_freq, 0) - # find right v-offset - test_model = model.get_model_copy() - test_model.set_variable("noise_strength", 0) - v_offset = test_model.find_v_offset(self.baseline_freq, base_stimulus) - model.set_variable("v_offset", v_offset) - - error_list = self.calculate_errors(error_weights) - - return sum(error_list) - def calculate_errors(self, error_weights=None, model=None): if model is None: model = self.base_model diff --git a/run_Fitter.py b/run_Fitter.py index fadf497..76a7aa1 100644 --- a/run_Fitter.py +++ b/run_Fitter.py @@ -1,6 +1,6 @@ from models.LIFACnoise import LifacNoiseModel -from CellData import icelldata_of_dir, CellData +from CellData import CellData from Baseline import get_baseline_class from FiCurve import get_fi_curve_class from Fitter import Fitter @@ -8,15 +8,16 @@ from ModelFit import ModelFit import time import os -import copy import argparse import numpy as np import multiprocessing as mp -SAVE_PATH_PREFIX = "" -FIT_ROUTINE = "" +SAVE_DIRECTORY = "./results/invivo_results/" +SAVE_DIRECTORY_BEST = "./results/invivo_best/" +# [bf, vs, sc, cv, bursty, f_inf, f_inf_slope, f_zero, f_zero_slope, f0_curve] +ERROR_WEIGHTS = (0, 2, 2, 2, 2, 1, 1, 1, 0, 1) def main(): @@ -43,28 +44,28 @@ def test_single_cell(path): for i, p in enumerate(start_parameters): fitter = Fitter() fitter.set_data_reference_values(cell_data) - fmin, res_par = fitter.fit_routine_1(p) + fmin, res_par = fitter.fit_routine(p, ERROR_WEIGHTS) - cell_path = os.path.basename(cell_data.get_data_path()) + cell_path = os.path.split(cell_data.get_data_path())[-1] error = fitter.calculate_errors(model=LifacNoiseModel(res_par)) - save_path = "results/invivo_bursty_results/" + cell_path + "/start_parameter_{:}_err_{:.2f}/".format(i, sum(error)) + save_path = SAVE_DIRECTORY + cell_path + "/start_parameter_{:}_err_{:.2f}/".format(i, sum(error)) save_fitting_run_info(cell_data, res_par, p, plot=True, save_path=save_path) print("Done with start parameters {}".format(str(i))) def fit_cell_base(parameters): - # parameter = (cell_data, start_parameter_index, start_parameter, results_base_folder) + # parameter = (cell_data, start_parameter_index, start_parameter) time1 = time.time() fitter = Fitter() fitter.set_data_reference_values(parameters[0]) - fmin, res_par = fitter.fit_routine_1(parameters[2]) + fmin, res_par = fitter.fit_routine(parameters[2], ERROR_WEIGHTS) cell_data = parameters[0] cell_path = os.path.split(cell_data.get_data_path())[-1] error = fitter.calculate_errors(model=LifacNoiseModel(res_par)) - save_path = parameters[3] + "/" + cell_path + "/start_parameter_{:}_err_{:.2f}/".format(parameters[1], sum(error)) + save_path = SAVE_DIRECTORY + "/" + cell_path + "/start_parameter_{:}_err_{:.2f}/".format(parameters[1], sum(error)) save_fitting_run_info(parameters[0], res_par, parameters[2], plot=True, save_path=save_path) time2 = time.time() @@ -77,15 +78,15 @@ def fit_cell_base(parameters): def fit_cell_parallel(cell_data, start_parameters): cell_path = os.path.basename(cell_data.get_data_path()) - save_directory = "./results/invivo_results/" - save_path_cell = os.path.join(save_directory, cell_data.get_cell_name()) + save_path_cell = os.path.join(SAVE_DIRECTORY, cell_data.get_cell_name()) + print(cell_path) core_count = mp.cpu_count() pool = mp.Pool(core_count - 1) parameters = [] for i, p in enumerate(start_parameters): - parameters.append((cell_data, i, p, save_directory)) + parameters.append((cell_data, i, p)) time1 = time.time() pool.map(fit_cell_base, parameters) @@ -94,6 +95,10 @@ def fit_cell_parallel(cell_data, start_parameters): del pool del cell_data + save_master_plot(save_path_cell) + + +def save_master_plot(save_path_cell): best_fit = None min_err = np.inf for fit in os.listdir(save_path_cell): @@ -102,7 +107,7 @@ def fit_cell_parallel(cell_data, start_parameters): min_err = cur_fit.comparable_error() best_fit = cur_fit - best_fit.generate_master_plot("./results/invivo_best/") + best_fit.generate_master_plot(SAVE_DIRECTORY_BEST) def iget_start_parameters(): diff --git a/tests/old_fit_routines.py b/tests/old_fit_routines.py deleted file mode 100644 index 08e5c62..0000000 --- a/tests/old_fit_routines.py +++ /dev/null @@ -1,127 +0,0 @@ -def fit_routine_1(self, cell_data=None): - global SAVE_PATH_PREFIX - SAVE_PATH_PREFIX = "fit_routine_1_" - # errors: [error_bf, error_vs, error_sc, error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope] - self.counter = 0 - # fit only v_offset, mem_tau, noise_strength, input_scaling - x0 = np.array([0.02, 0.03, 70]) - initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (1, 1, 1, 1, 1, 0, 0) - fmin_step1 = minimize(fun=self.cost_function_with_fixed_adaption_tau, args=(self.tau_a, self.delta_a, error_weights), - x0=x0, method="Nelder-Mead", - options={"initial_simplex": initial_simplex}) - res_parameters_step1 = self.base_model.get_parameters() - - if cell_data is not None: - print("##### After step 1: (fixed adaption)") - print_comparision_cell_model(cell_data, res_parameters_step1) - - self.counter = 0 - x0 = np.array([res_parameters_step1["mem_tau"], res_parameters_step1["noise_strength"], - res_parameters_step1["input_scaling"], res_parameters_step1["tau_a"], - res_parameters_step1["delta_a"]]) - initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (1, 1, 1, 1, 1, 2, 4) - fmin_step2 = minimize(fun=self.cost_function_all, args=(error_weights), x0=x0, method="Nelder-Mead", - options={"initial_simplex": initial_simplex}) - res_parameters_step2 = self.base_model.get_parameters() - - if cell_data is not None: - print("##### After step 2: (Everything)") - # print_comparision_cell_model(cell_data, res_parameters_step2) - - return fmin_step2, res_parameters_step2 - - -def fit_routine_2(self, cell_data=None): - global SAVE_PATH_PREFIX - SAVE_PATH_PREFIX = "fit_routine_2_" - # errors: [error_bf, error_vs, error_sc, error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope] - self.counter = 0 - # fit only v_offset, mem_tau, noise_strength, input_scaling - x0 = np.array([0.02, 0.03, 70]) - initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (1, 1, 5, 1, 2, 0, 0) - fmin = minimize(fun=self.cost_function_with_fixed_adaption_tau, - args=(self.tau_a, self.delta_a, error_weights), x0=x0, method="Nelder-Mead", - options={"initial_simplex": initial_simplex}) - res_parameters = self.base_model.get_parameters() - - return fmin, res_parameters - - -def fit_routine_3(self, cell_data=None): - global SAVE_PATH_PREFIX - SAVE_PATH_PREFIX = "fit_routine_3_" - # errors: [error_bf, error_vs, error_sc, error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope] - self.counter = 0 - # fit only v_offset, mem_tau, noise_strength, input_scaling, dend_tau - x0 = np.array([0.02, 0.03, 70, 0.001]) - initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (1, 1, 5, 1, 2, 0, 0) - fmin = minimize(fun=self.cost_function_with_fixed_adaption_with_dend_tau, - args=(self.tau_a, self.delta_a, error_weights), x0=x0, method="Nelder-Mead", - options={"initial_simplex": initial_simplex}) - res_parameters = self.base_model.get_parameters() - - return fmin, res_parameters - - -def fit_routine_4(self, cell_data=None, start_parameters=None): - global SAVE_PATH_PREFIX - SAVE_PATH_PREFIX = "fit_routine_4_" - # errors: [error_bf, error_vs, error_sc, error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope] - self.counter = 0 - # fit only v_offset, mem_tau, input_scaling, dend_tau - if start_parameters is None: - x0 = np.array([0.02, 70, 0.001]) - else: - x0 = np.array([start_parameters["mem_tau"], start_parameters["noise_strength"], - start_parameters["input_scaling"], start_parameters["dend_tau"]]) - initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (0, 5, 15, 1, 2, 1, 0) - fmin = minimize(fun=self.cost_function_with_fixed_adaption_with_dend_tau, - args=(self.tau_a, self.delta_a, error_weights), - x0=x0, method="Nelder-Mead", - options={"initial_simplex": initial_simplex, "xatol": 0.001, "maxfev": 400, "maxiter": 400}) - res_parameters = fmin.x - - # print_comparision_cell_model(cell_data, self.base_model.get_parameters()) - - self.counter = 0 - x0 = np.array([self.tau_a, - self.delta_a, res_parameters[0]]) - initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (0, 1, 1, 2, 2, 4, 2) - fmin = minimize(fun=self.cost_function_only_adaption, - args=(error_weights,), x0=x0, method="Nelder-Mead", - options={"initial_simplex": initial_simplex, "xatol": 0.001}) - print(fmin) - print_comparision_cell_model(cell_data, self.base_model.get_parameters()) - - # - # # self.counter = 0 - # # x0 = np.array([res_parameters[0], - # # res_parameters[1], self.tau_a, - # # self.delta_a, res_parameters[2]]) - # # initial_simplex = create_init_simples(x0, search_scale=2) - # # error_weights = (1, 3, 1, 2, 1, 3, 2) - # # fmin = minimize(fun=self.cost_function_all_without_noise, - # # args=(error_weights,), x0=x0, method="Nelder-Mead", - # # options={"initial_simplex": initial_simplex, "xatol": 0.001}) - # # res_parameters = self.base_model.get_parameters() - # # - # # print_comparision_cell_model(cell_data, self.base_model.get_parameters()) - # - # self.counter = 0 - # x0 = np.array([res_parameters[0], start_parameters["noise_strength"], - # res_parameters[1], res_parameters[2], - # res_parameters[3], res_parameters[4]]) - # initial_simplex = create_init_simples(x0, search_scale=2) - # error_weights = (0, 1, 2, 1, 1, 3, 2) - # fmin = minimize(fun=self.cost_function_all, - # args=(error_weights,), x0=x0, method="Nelder-Mead", - # options={"initial_simplex": initial_simplex, "xatol": 0.001, "maxiter": 599}) - # res_parameters = self.base_model.get_parameters() - - return fmin, self.base_model.get_parameters()