Alexander/P-unit_model
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

code clean up

Browse Source
This commit is contained in:
a.ott 2020-07-28 10:54:02 +02:00
parent 90ccb4459d
commit c5b72bec26
3 changed files with 28 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
Fitter.py
View File

@ -16,13 +16,9 @@ import matplotlib.pyplot as plt
class Fitter: class Fitter:
def __init__(self, params=None): def __init__(self):
if params is None:
self.base_model = LifacNoiseModel({"step_size": 0.00005}) 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)
self.best_parameters_found = [] self.best_parameters_found = []
self.smallest_error = np.inf self.smallest_error = np.inf
@ -57,8 +53,6 @@ class Fitter:
self.errors = [] self.errors = []
# self.tau_a = 0
# counts how often the cost_function was called # counts how often the cost_function was called
self.counter = 0 self.counter = 0
@ -115,7 +109,7 @@ class Fitter:
self.set_data_reference_values(data) self.set_data_reference_values(data)
return fit_routine_func(start_parameters) 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 self.counter = 0
# fit only v_offset, mem_tau, input_scaling, dend_tau # fit only v_offset, mem_tau, input_scaling, dend_tau
@ -126,7 +120,10 @@ class Fitter:
# error_list = [error_bf, error_vs, error_sc, error_cv, error_bursty, # 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_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) error_weights = (1, 2, 2, 2, 2, 1, 1, 1, 0, 1)
fmin = minimize(fun=self.cost_function_all, fmin = minimize(fun=self.cost_function_all,
args=(error_weights,), x0=x0, method="Nelder-Mead", args=(error_weights,), x0=x0, method="Nelder-Mead",
options={"initial_simplex": initial_simplex, "xatol": 0.001, "maxfev": 600, "maxiter": 400}) options={"initial_simplex": initial_simplex, "xatol": 0.001, "maxfev": 600, "maxiter": 400})
@ -167,125 +164,6 @@ class Fitter:
self.best_parameters_found = X self.best_parameters_found = X
return sum(error_list) 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): def calculate_errors(self, error_weights=None, model=None):
if model is None: if model is None:
model = self.base_model model = self.base_model

33
run_Fitter.py
View File

@ -1,6 +1,6 @@
from models.LIFACnoise import LifacNoiseModel from models.LIFACnoise import LifacNoiseModel
from CellData import icelldata_of_dir, CellData from CellData import CellData
from Baseline import get_baseline_class from Baseline import get_baseline_class
from FiCurve import get_fi_curve_class from FiCurve import get_fi_curve_class
from Fitter import Fitter from Fitter import Fitter
@ -8,15 +8,16 @@ from ModelFit import ModelFit
import time import time
import os import os
import copy
import argparse import argparse
import numpy as np import numpy as np
import multiprocessing as mp import multiprocessing as mp
SAVE_PATH_PREFIX = "" SAVE_DIRECTORY = "./results/invivo_results/"
FIT_ROUTINE = "" 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(): def main():
@ -43,28 +44,28 @@ def test_single_cell(path):
for i, p in enumerate(start_parameters): for i, p in enumerate(start_parameters):
fitter = Fitter() fitter = Fitter()
fitter.set_data_reference_values(cell_data) 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)) 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) save_fitting_run_info(cell_data, res_par, p, plot=True, save_path=save_path)
print("Done with start parameters {}".format(str(i))) print("Done with start parameters {}".format(str(i)))
def fit_cell_base(parameters): 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() time1 = time.time()
fitter = Fitter() fitter = Fitter()
fitter.set_data_reference_values(parameters[0]) 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_data = parameters[0]
cell_path = os.path.split(cell_data.get_data_path())[-1] cell_path = os.path.split(cell_data.get_data_path())[-1]
error = fitter.calculate_errors(model=LifacNoiseModel(res_par)) 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) save_fitting_run_info(parameters[0], res_par, parameters[2], plot=True, save_path=save_path)
time2 = time.time() time2 = time.time()
@ -77,15 +78,15 @@ def fit_cell_base(parameters):
def fit_cell_parallel(cell_data, start_parameters): def fit_cell_parallel(cell_data, start_parameters):
cell_path = os.path.basename(cell_data.get_data_path()) 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) print(cell_path)
core_count = mp.cpu_count() core_count = mp.cpu_count()
pool = mp.Pool(core_count - 1) pool = mp.Pool(core_count - 1)
parameters = [] parameters = []
for i, p in enumerate(start_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() time1 = time.time()
pool.map(fit_cell_base, parameters) pool.map(fit_cell_base, parameters)
@ -94,6 +95,10 @@ def fit_cell_parallel(cell_data, start_parameters):
del pool del pool
del cell_data del cell_data
save_master_plot(save_path_cell)
def save_master_plot(save_path_cell):
best_fit = None best_fit = None
min_err = np.inf min_err = np.inf
for fit in os.listdir(save_path_cell): 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() min_err = cur_fit.comparable_error()
best_fit = cur_fit best_fit = cur_fit
best_fit.generate_master_plot("./results/invivo_best/") best_fit.generate_master_plot(SAVE_DIRECTORY_BEST)
def iget_start_parameters(): def iget_start_parameters():

127
tests/old_fit_routines.py
View File

@ -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()