code clean up
This commit is contained in:
a.ott
parent
90ccb4459d
commit
c5b72bec26
140
Fitter.py
140
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
|
||||
|
||||
@ -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():
|
||||
|
||||
@ -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()
|
||||
Loading…
Reference in New Issue
Block a user