def eqtn_x0cr_r(Iext1, yc, a, b, d, x1_rest, x1_cr, x0_rest, x0_cr, zmode=np.array("lin")): # Correspondence with EpileptorDP2D b = b - d if isequal_string(str(zmode), 'lin'): return 0.25 * (x0_rest * (a * x1_cr ** 3 - a * x1_rest ** 3 - b * x1_cr ** 2 + b * x1_rest ** 2 + 4.0 * x1_cr - 4.0 * x1_rest) + (x0_cr - x0_rest) * (Iext1 - a * x1_rest ** 3 + b * x1_rest ** 2 - 4.0 * x1_rest + yc)) / (x0_cr - x0_rest), \ 0.25 * (a * x1_cr ** 3 - a * x1_rest ** 3 - b * x1_cr ** 2 + b * x1_rest ** 2 + 4.0 * x1_cr - 4.0 * x1_rest) / (x0_cr - x0_rest) elif isequal_string(str(zmode), 'sig'): return (-x0_cr*(3.2e+66*20000000000000.0**(10*x1_cr) + 4.74922109128249e+68*54365636569181.0**(10*x1_cr)) *(3.2e+66*1.024e+133**x1_rest*(Iext1 - a*x1_rest**3 + b*x1_rest**2 + yc) + 4.74922109128249e+68*2.25551009738825e+137**x1_rest*(Iext1 - a*x1_rest**3 + b*x1_rest**2 + yc - 3.0)) + x0_rest*(3.2e+66*20000000000000.0**(10*x1_rest) + 4.74922109128249e+68*54365636569181.0**(10*x1_rest))*(3.2e+66*1.024e+133**x1_cr*(Iext1 - a*x1_cr**3 + b*x1_cr**2 + yc) + 4.74922109128249e+68*2.25551009738825e+137**x1_cr*(Iext1 - a*x1_cr**3 + b*x1_cr**2 + yc - 3.0)))/((3.2e+66*20000000000000.0**(10.0*x1_cr) + 4.74922109128249e+68*54365636569181.0**(10.0*x1_cr))*(3.2e+66*20000000000000.0**(10.0*x1_rest) + 4.74922109128249e+68*54365636569181.0**(10.0*x1_rest))*(-x0_cr + x0_rest)), \ (-(3.2e+66 * 20000000000000.0 ** (10 * x1_cr) + 4.74922109128249e+68 * 54365636569181.0 ** (10 * x1_cr)) * (3.2e+66 * 1.024e+133 ** x1_rest * ( Iext1 - a * x1_rest ** 3 + b * x1_rest ** 2 + yc) + 4.74922109128249e+68 * 2.25551009738825e+137 ** x1_rest * ( Iext1 - a * x1_rest ** 3 + b * x1_rest ** 2 + yc - 3.0)) + ( 3.2e+66 * 20000000000000.0 ** (10 * x1_rest) + 4.74922109128249e+68 * 54365636569181.0 ** ( 10 * x1_rest)) * (3.2e+66 * 1.024e+133 ** x1_cr * (Iext1 - a * x1_cr ** 3 + b * x1_cr ** 2 + yc) + 4.74922109128249e+68 * 2.25551009738825e+137 ** x1_cr * (Iext1 - a * x1_cr ** 3 + b * x1_cr ** 2 + yc - 3.0))) / \ ((3.2e+66 * 20000000000000.0 ** (10.0 * x1_cr) + 4.74922109128249e+68 * 54365636569181.0 ** ( 10.0 * x1_cr)) * (3.2e+66 * 20000000000000.0 ** (10.0 * x1_rest) + 4.74922109128249e+68 * 54365636569181.0 ** (10.0 * x1_rest)) * (-x0_cr + x0_rest)) else: raise_value_error('zmode is neither "lin" nor "sig"')
def _sort_disease_indices_values(self, disease_dict): indices = [] values = [] for key, value in disease_dict.iteritems(): value = ensure_list(value) key = ensure_list(key) n = len(key) if n > 0: indices += key if len(value) == n: values += value elif len(value) == 1 and n > 1: values += value * n else: raise_value_error("Length of disease indices " + str(n) + " and values " + str(len(value)) + " do not match!") if len(indices) > 0: if isinstance(indices[0], tuple): arg_sort = np.ravel_multi_index( indices, (self.number_of_regions, self.number_of_regions)).argsort() else: arg_sort = np.argsort(indices) return np.array(indices)[arg_sort].tolist(), np.array( values)[arg_sort] else: return [], []
def __update_params__(self, loc=0.0, scale=1.0, use="scipy", check_constraint=True, **params): if len(params) == 0: params = self.pdf_params() self.__set_params__(**params) # params = self.__squeeze_parameters__(update=False, loc=loc, scale=scale, use=use) # self.__set_params__(**params) self.__p_shape = self.__update_shape__(loc, scale) self.__p_size = shape_to_size(self.p_shape) self.n_params = len(self.pdf_params()) if check_constraint and not (self.__check_constraint__()): raise_value_error("Constraint for " + self.type + " distribution " + self.constraint_string + "\nwith parameters " + str(self.pdf_params()) + " is not satisfied!") self.__mean = self._calc_mean(loc, scale, use) self.__median = self._calc_median(loc, scale, use) self.__mode = self._calc_mode(loc, scale) self.__var = self._calc_var(loc, scale, use) self.__std = self._calc_std(loc, scale, use) self.__skew = self._calc_skew() self.__kurt = self._calc_kurt()
def eqtn_fz_square_taylor(zeq, yc, Iext1, K, w, tau1, tau0): n_regions = zeq.size tau = np.divide(tau1, tau0) tau = np.repeat(tau.T, n_regions, 1) # The z derivative of the function # x1 = F(z) = -4/3 -1/2*sqrt(2(z-yc-Iext1)+64/27) dfz = -np.divide(0.5, np.power(2.0 * (zeq - yc - Iext1) + 64.0 / 27.0, 0.5)) # Tim Proix: dfz = -np.divide(1, np.power(8.0 * zeq - 629.6/27, 0.5)) try: if np.any([np.any(np.isnan(dfz)), np.any(np.isinf(dfz))]): raise_value_error("nan or inf values in dfz") except: pass # Jacobian: diagonal elements at first row # Diagonal elements: -1 + dfz_i * (4 + K_i * sum_j_not_i{wij}) # Off diagonal elements: -K_i * wij_not_i * dfz_j_not_i i = np.ones((1, n_regions), dtype=np.float32) fz_jac = np.diag((-1.0 + np.multiply(dfz, (4.0 + np.multiply(K, np.expand_dims(np.sum(w, axis=1), 1).T)))).T[:, 0]) - np.multiply(np.multiply(np.dot(K.T, i), np.dot(i.T, dfz)), w) try: if np.any([np.any(np.isnan(fz_jac.flatten())), np.any(np.isinf(fz_jac.flatten()))]): raise_value_error("nan or inf values in dfz") except: pass return np.multiply(fz_jac, tau)
def _prepare_distribution_axes(self, distribution, loc=0.0, scale=1.0, x=numpy.array([]), ax=None, linestyle="-", lgnd=False): if len(x) < 1: x = linspace_broadcast( distribution._scipy_method("ppf", distribution.loc, distribution.scale, 0.01), distribution._scipy_method("ppf", distribution.loc, distribution.scale, 0.99), 100) if x is not None: if x.ndim == 1: x = x[:, numpy.newaxis] pdf = distribution._scipy_method("pdf", loc, scale, x) if ax is None: _, ax = pyplot.subplots(1, 1) for ip, (xx, pp) in enumerate(zip(x.T, pdf.T)): ax.plot(xx.T, pp.T, linestyle=linestyle, linewidth=1, label=str(ip), alpha=0.5) if lgnd: pyplot.legend() return ax else: # TODO: is this message correct?? raise_value_error("Distribution parameters do not broadcast!")
def prepare_params(self, params_pse): if isinstance(params_pse, list): temp = [] for param in params_pse: self.params_paths.append(param["path"]) temp2 = param["samples"].flatten() temp.append(temp2) self.n_params_vals.append(temp2.size) indices = param.get("indices", []) self.params_indices.append(indices) self.params_names.append( param.get("name", param["path"].rsplit('.', 1)[-1] + str(indices))) self.n_params_vals = np.array(self.n_params_vals) self.n_params = len(self.params_paths) if not (np.all(self.n_params_vals == self.n_params_vals[0])): raise_value_error( "\nNot all parameters have the same number of samples!: " + "\n" + str(self.params_paths) + " = " + str(self.n_params_vals)) else: self.n_params_vals = self.n_params_vals[0] self.params_vals = np.vstack(temp).T self.params_paths = np.array(self.params_paths) self.params_indices = np.array(self.params_indices) self.n_loops = self.params_vals.shape[0] print "\nGenerated a parameter search exploration for " + str( "lsa/sim task") + "," print "with " + str(self.n_params) + " parameters of " + str( self.n_params_vals) + " values each," print "leading to " + str(self.n_loops) + " total execution loops" else: self.logger.warning("\nparams_pse is not a list of tuples!")
def _compute_jacobian(self, model_configuration): # Check if any of the equilibria are in the supercritical regime (beyond the separatrix) and set it right before # the bifurcation. zeq = model_configuration.zeq if self.lsa_method == "2D": fz_jacobian = calc_jac(model_configuration.x1eq, model_configuration.zeq, model_configuration.yc, model_configuration.Iext1, model_configuration.x0, model_configuration.K, model_configuration.model_connectivity, model_vars=2, zmode="lin", a=model_configuration.a, b=model_configuration.b, d=model_configuration.d, tau1= model_configuration.tau1, tau0=model_configuration.tau0) else: temp = model_configuration.x1eq > X1EQ_CR_DEF - 10 ** (-3) if temp.any(): correction_value = X1EQ_CR_DEF - 10 ** (-3) self.logger.warning("Equilibria x1eq[" + str(numpy.where(temp)[0]) + "] = " + str(model_configuration.x1eq[temp]) + "\nwere corrected for LSA to value: X1EQ_CR_DEF - 10 ** (-3) = " + str(correction_value) + " to be sub-critical!") model_configuration.x1eq[temp] = correction_value i_temp = numpy.ones(model_configuration.x1eq.shape) zeq[temp] = calc_eq_z(model_configuration.x1eq[temp], model_configuration.yc * i_temp[temp], model_configuration.Iext1 * i_temp[temp], "2d", 0.0, model_configuration.slope * i_temp[temp], model_configuration.a * i_temp[temp], model_configuration.b * i_temp[temp], model_configuration.d * i_temp[temp]) fz_jacobian = calc_fz_jac_square_taylor(model_configuration.zeq, model_configuration.yc, model_configuration.Iext1, model_configuration.K, model_configuration.model_connectivity, model_configuration.a, model_configuration.b, model_configuration.d) if numpy.any([numpy.any(numpy.isnan(fz_jacobian.flatten())), numpy.any(numpy.isinf(fz_jacobian.flatten()))]): raise_value_error("nan or inf values in dfz") return fz_jacobian
def __init__(self, name="Parameter", low=-CalculusConfig.MAX_SINGLE_VALUE, high=CalculusConfig.MAX_SINGLE_VALUE, loc=0.0, scale=1.0, p_shape=(), use="scipy", **target_params): StochasticParameterBase.__init__(self, name, low, high, loc, scale, p_shape) thisProbabilityDistribution.__init__(self, **target_params) success = True for p_key, p_val in target_params.iteritems(): if np.any(p_val != getattr(self, p_key)): success = False if success is False: if optimize_pdf: pdf_params = compute_pdf_params( probability_distribution.lower(), target_params, loc, scale, use) thisProbabilityDistribution.__init__(self, **pdf_params) success = True for p_key, p_val in target_params.iteritems(): if np.any(np.abs(p_val - getattr(self, p_key)) > 0.1): success = False if success is False: raise_value_error( "Cannot generate probability distribution of type " + probability_distribution + " with parameters " + str(target_params) + " !") self._update_params(use=use)
def eqtn_jac_fz_2d(x1, z, tau1, tau0, zmode=np.array("lin"), z_pos=True, K=None, w=None): tau = np.divide(tau1, tau0) jac_z = -np.ones(z.shape, dtype=z.dtype) if zmode == 'lin': jac_x1 = 4.0 * np.ones(z.shape, dtype=z.dtype) if not (z_pos): jac_z -= 0.7 * np.power(z, 6.0) elif zmode == 'sig': jac_x1 = np.divide(30 * np.power(np.exp(1), (-10.0 * (x1 + 0.5))), 1 + np.power(np.exp(1), (-10.0 * (x1 + 0.5)))) else: raise_value_error('zmode is neither "lin" nor "sig"') # Assuming that wii = 0 jac_x1 += np.multiply(K, np.sum(w, 1)) jac_x1 = np.diag(jac_x1.flatten()) - np.multiply( np.repeat(np.reshape(K, (x1.size, 1)), x1.size, axis=1), w) jac_x1 *= np.repeat(np.reshape(tau, (x1.size, 1)), x1.size, axis=1) jac_z *= tau jac_z = np.diag(jac_z.flatten()) return np.concatenate([jac_x1, jac_z], axis=1)
def set_sensors(self, input_sensors, s_type=Sensors.TYPE_SEEG, reset=False): if input_sensors is None: return sensors = ensure_list(self.get_sensors(s_type)) if reset is False or len(sensors) == 0: sensors = [] for s in ensure_list(input_sensors): if isinstance(s, Sensors) and (s.s_type == s_type): if s.gain_matrix is None or s.gain_matrix.shape != ( s.number_of_sensors, self.number_of_regions): self.logger.warning( "No correctly sized gain matrix found in sensors! Computing and adding gain matrix!" ) s.gain_matrix = s.compute_gain_matrix(self.connectivity) # if s.orientations == None or s.orientations.shape != (s.number_of_sensors, 3): # self.logger.warning("No orientations found in sensors!") sensors.append(s) else: if s is not None: raise_value_error( "Input sensors:\n" + str(s) + "\nis not a valid Sensors object of type " + str(s_type) + "!") if len(sensors) == 0: setattr(self, "sensors" + s_type, []) else: setattr(self, "sensors" + s_type, sensors)
def compute_nearest_regions_to_sensors(self, head, sensors=None, target_contacts=None, s_type=Sensors.TYPE_SEEG, sensors_id=0, n_regions=None, gain_matrix_th=None): if not (isinstance(sensors, Sensors)): sensors = head.get_sensors_id(s_type=s_type, sensor_ids=sensors_id) n_contacts = sensors.labels.shape[0] if isinstance(target_contacts, (list, tuple, np.ndarray)): target_contacts = ensure_list(target_contacts) for itc, tc in enumerate(target_contacts): if isinstance(tc, int): continue elif isinstance(tc, basestring): target_contacts[itc] = sensors.contact_label_to_index([tc]) else: raise_value_error("target_contacts[" + str(itc) + "] = " + str(tc) + "is neither an integer nor a string!") else: target_contacts = range(n_contacts) auto_flag = False if n_regions is "all": n_regions = head.connectivity.number_of_regions elif not (isinstance(n_regions, int)): auto_flag = True nearest_regions = [] for tc in target_contacts: projs = sensors.gain_matrix[tc] inds = np.argsort(projs)[::-1] if auto_flag: n_regions = select_greater_values_array_inds(projs[inds], threshold=gain_matrix_th) inds = inds[:n_regions] nearest_regions.append((inds, head.connectivity.region_labels[inds], projs[inds])) return nearest_regions
def _check_regions_inds_range(self, indices, type): if numpy.any(numpy.array(indices) < 0) or numpy.any(numpy.array(indices) >= self.number_of_regions): raise_value_error(type + "_indices out of range! " + "\nThe maximum indice is " + str(self.number_of_regions) + " for number of brain regions " + str(self.number_of_regions) + " but" "\n" + type + "_indices = " + str(indices)) return indices
def set_model_name(self, model_name): # TODO: check that model_name is one of the available ones if model_name not in AVAILABLE_DYNAMICAL_MODELS_NAMES: raise_value_error(model_name + " is not one of the available models: \n" + str(AVAILABLE_DYNAMICAL_MODELS_NAMES) + " !") self.model_name = model_name return self
def __init__(self, model_name=None, model=None, model_code=None, model_code_path="", model_data_path="", fitmethod="sample", random_seed=12345, init="random", config=None, **options): super(CmdStanService, self).__init__(model_name, model, model_code, model_code_path, model_data_path, fitmethod, config) if not os.path.isfile( os.path.join(self.config.generic.CMDSTAN_PATH, 'runCmdStanTests.py')): raise_value_error( 'Please provide CmdStan path, e.g. lib.cmdstan_path("/path/to/")!' ) self.path = self.config.generic.CMDSTAN_PATH self.assert_fitmethod() self.command = "" self.options = {"init": init, "random_seed": random_seed} self.options = self.set_options(**options) self.context_str = "from " + construct_import_path( __file__) + " import " + self.__class__.__name__ self.create_str = self.__class__.__name__ + "()"
def set_diseased_regions_values(self, disease_values): n = len(disease_values) if n != self.number_of_regions: raise_value_error("Diseased region values size (" + str(n) + ") doesn't match the number of regions (" + str(self.number_of_regions) + ")!") self.diseased_regions_values = disease_values return self
def write_ts_epi(self, raw_ts, sampling_period, path, source_ts=None): path = change_filename_or_overwrite(os.path.join(path)) if raw_ts is None or len(raw_ts.squeezed.shape) != 3: raise_value_error( "Invalid TS data 3D (time, regions, sv) expected", self.logger) self.logger.info("Writing a TS at:\n" + path) if source_ts is None: source_ts = raw_ts.source h5_file = h5py.File(path, 'a', libver='latest') h5_file.create_dataset("/data", data=raw_ts.squeezed) h5_file.create_dataset("/lfpdata", data=source_ts.squeezed) write_metadata({KEY_TYPE: "TimeSeries"}, h5_file, KEY_DATE, KEY_VERSION) write_metadata( { KEY_MAX: raw_ts.squeezed.max(), KEY_MIN: raw_ts.squeezed.min(), KEY_STEPS: raw_ts.squeezed.shape[0], KEY_CHANNELS: raw_ts.squeezed.shape[1], KEY_SV: raw_ts.squeezed.shape[2], KEY_SAMPLING: sampling_period, KEY_START: raw_ts.time_start }, h5_file, KEY_DATE, KEY_VERSION, "/data") write_metadata( { KEY_MAX: source_ts.squeezed.max(), KEY_MIN: source_ts.squeezed.min(), KEY_STEPS: source_ts.squeezed.shape[0], KEY_CHANNELS: source_ts.squeezed.shape[1], KEY_SV: 1, KEY_SAMPLING: sampling_period, KEY_START: source_ts.time_start }, h5_file, KEY_DATE, KEY_VERSION, "/lfpdata") h5_file.close()
def _ensure_eigen_vectors_number(self, eigen_values, e_values, x0_values, disease_indices): if self.eigen_vectors_number is None: if self.eigen_vectors_number_selection is "auto_eigenvals": self.eigen_vectors_number = self.get_curve_elbow_point( numpy.abs(eigen_values)) + 1 elif self.eigen_vectors_number_selection is "auto_disease": self.eigen_vectors_number = len(disease_indices) elif self.eigen_vectors_number_selection is "auto_epileptogenicity": self.eigen_vectors_number = self.get_curve_elbow_point( e_values) + 1 elif self.eigen_vectors_number_selection is "auto_excitability": self.eigen_vectors_number = self.get_curve_elbow_point( x0_values) + 1 else: raise_value_error( "\n" + self.eigen_vectors_number_selection + "is not a valid option when for automatic computation of self.eigen_vectors_number" ) else: self.eigen_vectors_number_selection = "user_defined"
def prepare_target_stats(distribution, target_stats, loc=0.0, scale=1.0): # Make sure that the shapes of target stats are all matching one to the other: target_shape = np.ones(()) * loc * scale target_shape = np.ones(target_shape.shape) try: for ts in target_stats.values(): target_shape = target_shape * np.ones(np.array(ts).shape) except: raise_value_error( "Target statistics (" + str([np.array(ts).shape for ts in target_stats.values()]) + ") and distribution (" + str(distribution.p_shape) + ") shapes do not propagate!") for ts_key in target_stats.keys(): target_stats[ts_key] *= target_shape if np.sum(target_stats[ts_key].shape) > 0: target_stats[ts_key] = target_stats[ts_key].flatten() target_size = target_shape.size target_shape = target_shape.shape target_stats_array = np.around(np.vstack(target_stats.values()).T, decimals=2) target_stats_unique = np.unique(target_stats_array, axis=0) # target_stats_unique = np.vstack({tuple(row) for row in target_stats_array}) target_stats_unique = dict( zip(target_stats.keys(), [ np.around(target_stats_unique[:, ii], decimals=3) for ii in range(distribution.n_params) ])) target_stats_unique = dicts_of_lists_to_lists_of_dicts(target_stats_unique) return target_stats_unique, target_stats_array, target_shape, target_size
def eqtn_fz(x1, z, x0, tau1, tau0, zmode=np.array("lin"), z_pos=True, K=None, w=None, coupl=None): if coupl is None: if np.all(K == 0.0) or np.all(w == 0.0) or (K is None) or (w is None): coupl = 0.0 else: from tvb_epilepsy.base.computations.calculations_utils import calc_coupling coupl = calc_coupling(x1, K, w) tau = np.divide(tau1, tau0) if zmode == 'lin': return np.multiply( (4 * (x1 - x0) - np.where(z_pos, z, z + 0.1 * np.power(z, 7.0)) - coupl), tau) elif zmode == 'sig': return np.multiply( np.divide(3.0, (1 + np.power(np.exp(1), (-10.0 * (x1 + 0.5))))) - x0 - z - coupl, tau) else: raise_value_error('zmode is neither "lin" nor "sig"')
def _set_conf_level(self, conf_level): if isinstance(conf_level, float) and conf_level > 0.0 and conf_level < 1.0: self.conf_level = conf_level else: raise_value_error( "conf_level = " + str(conf_level) + "is not a float in the (0.0, 1.0) interval as it should!")
def _set_method(self, method): method = method.lower() if np.in1d(method, METHODS): self.method = method else: raise_value_error("Method " + str(method) + " is not one of the available methods " + str(METHODS) + " !")
def update_active_regions(self, active_regions): if np.all(np.in1d(active_regions, range(self.number_of_regions))): self.active_regions = np.unique( ensure_list(active_regions) + self.active_regions).tolist() else: raise_value_error("Active regions indices:\n" + str(active_regions) + "\nbeyond number of regions (" + str(self.number_of_regions) + ")!")
def assert_fitmethod(self): if self.fitmethod.lower().find("sampl") >= 0: # for sample or sampling self.fitmethod = "sampling" elif self.fitmethod.lower().find("v") >= 0: # for variational or vb or advi self.fitmethod = "vb" elif self.fitmethod.lower().find("optimiz") >= 0: # for optimization or optimizing or optimize self.fitmethod = "optimizing" else: raise_value_error(self.fitmethod + " does not correspond to one of the input methods:\n" + "sampling, vb, optimizing")
def _check_indices_vals_sizes(self, indices, values, type): n_inds = len(indices) n_vals = len(values) if n_inds != n_vals: if n_vals != 1: values *= n_inds else: raise_value_error("Sizes of " + type + "_indices (" + str(n_inds) + ") " + "and " + type + "_values (" + str(n_vals) + ") do not match!") return values
def select_sensors_rois(self, sensors, rois=None, initial_selection=[], gain_matrix_th=0.5): if len(initial_selection) == 0: initial_selection = range(sensors.number_of_sensors) selection = [] if sensors.gain_matrix is None: raise_value_error("Projection matrix is not set!") else: for proj in sensors.gain_matrix[initial_selection].T[rois]: selection += ( np.array(initial_selection)[select_greater_values_array_inds(proj, gain_matrix_th)]).tolist() return np.unique(selection).tolist()
def check_number_of_inputs(nmodels, input, input_str): input = ensure_list(input) ninput = len(input) if ninput != nmodels: if ninput == 1: input *= nmodels else: raise_value_error("The size of input " + input_str + " (" + str(ninput) + ") is neither equal to the number of models (" + str(nmodels) + ") nor equal to 1!") return input
def generate_model(self, model_configuration): if isequal_string(self.model_name, EpileptorModel._ui_name) and not isequal_string( self.simulator, "java"): raise_value_error( "Custom EpileptorModel can be used only with java simulator!") elif not isequal_string(self.model_name, EpileptorModel._ui_name) and isequal_string( self.simulator, "java"): raise_value_error( "Only java EpileptorModel can be used with java simulator!") return model_build_dict[self.model_name](model_configuration)
def __init__( self, name='vep_ode', number_of_regions=0, active_regions=[], n_signals=0, n_times=0, dt=1.0, x1eq_min=X1EQ_MIN, x1eq_max=X1EQ_MAX, MC_scale=MC_SCALE, sig_init=SIG_INIT_DEF, observation_model=OBSERVATION_MODEL_DEF, # observation_expression=OBSERVATION_EXPRESSION_DEF, euler_method="forward", **defaults): super(ODEStatisticalModel, self).__init__(name, number_of_regions, x1eq_min, x1eq_max, MC_scale, **defaults) self.sig_init = sig_init if np.all(np.in1d(active_regions, range(self.number_of_regions))): self.active_regions = np.unique(active_regions).tolist() self.n_active_regions = len(self.active_regions) self.n_nonactive_regions = self.number_of_regions - self.n_active_regions else: raise_value_error("Active regions indices:\n" + str(active_regions) + "\nbeyond number of regions (" + str(self.number_of_regions) + ")!") self.n_signals = n_signals self.n_times = n_times self.dt = dt # if np.in1d(euler_method.lower(), EULER_METHODS): # if euler_method.lower() == "midpoint": # warning("Midpoint Euler method is not implemented yet! Switching to default forward one!") # self.euler_method = euler_method.lower() # else: # raise_value_error("Statistical model's euler_method " + str(euler_method) + " is not one of the valid ones: " # + str(["backward", "forward"]) + "!") # if np.in1d(observation_expression.lower(), OBSERVATION_MODEL_EXPRESSIONS): # self.observation_expression = observation_expression.lower() # else: # raise_value_error("Statistical model's observation expression " + str(observation_expression) + # " is not one of the valid ones: " # + str(OBSERVATION_MODEL_EXPRESSIONS) + "!") if np.in1d(observation_model.lower(), OBSERVATION_MODELS): self.observation_model = observation_model.lower() else: raise_value_error("Statistical model's observation expression " + str(observation_model) + " is not one of the valid ones: " + str(OBSERVATION_MODELS) + "!") self.__add_parameters(**defaults)
def set_normalize(self, values): values = ensure_list(values) n_vals = len(values) if n_vals > 0: if n_vals > 2: raise_value_error("Invalid disease hypothesis normalization values!: " + str(values) + "\nThey cannot be more than 2!") else: if n_vals < 2: # Assuming normalization only to a maximum value, keeping the existing minimum one values = [numpy.min(self.diseased_regions_values)] + values self.normalize_values = values return self
def eqtn_x0(x1, z, zmode=np.array("lin"), z_pos=True, K=None, w=None, coupl=None): if coupl is None: if np.all(K == 0.0) or np.all(w == 0.0) or (K is None) or (w is None): coupl = 0.0 else: from tvb_epilepsy.base.computations.calculations_utils import calc_coupling coupl = calc_coupling(x1, K, w) if isequal_string(str(zmode), 'lin'): return x1 - (z + np.where(z_pos, 0.0, 0.1 * np.power(z, 7.0)) + coupl) / 4.0 elif isequal_string(str(zmode), 'sig'): return np.divide(3.0, 1.0 + np.power(np.exp(1), -10.0 * (x1 + 0.5))) - z - coupl else: raise_value_error('zmode is neither "lin" nor "sig"')