def evaluate_model(params, i, D, return_dict): print("Starting sensitivity run %i out of %i" % (i + 1, len(D))) # Defining model parameters model_params, _ = data.get_params() for var, val in zip(vars, params): model_params[var] = val # Initiate and run models models = initiate_models(model_params) run_models(models) # Assign data to patches patches = data.assign_data(models) results = [] for t in range(measurements): t += 1 mean = get_average_biomass(models, t) loss = get_total_loss(patches, t) results += [*mean, *loss] return_dict[i] = results print("Finishing sensitivity run %i out of %i" % (i + 1, len(D))) return
def get_data(self): params = get_params(self.get_parameters_file()) params["back"] = self.get_cadence() print params selfStats = SelfSpy(params) # Get list of stats and create dict # RowId StartTime CreatedAt Duration Process WindowTitle keysPressed fields = selfStats.getKeysDict() return fields
def simple_exp(in_path, out_path=None, n_epochs=500, model_type="old"): (X_train, y_train), (X_test, y_test) = data.make_dataset(in_path) n_cats, n_channels = data.get_params(X_train, y_train) X_train, y_train = prepare_data(X_train, y_train, n_channels) X_test, y_test = prepare_data(X_test, y_test, n_channels) model_factory, params = models.get_model_factory(model_type) model = model_factory(n_cats, n_channels, params) model.summary() model.fit(X_train, y_train, epochs=n_epochs, batch_size=256) test_model(X_test, y_test, model) if (out_path): model.save(out_path)
def train_binary_model(in_path,out_path,n_epochs=150,model_type='exp'): (X_train,y_train),(X_test,y_test)=data.make_dataset(in_path) n_cats,n_channels=data.get_params(X_train,y_train) X_train,y_train=basic.prepare_data(X_train,y_train,n_channels) X_test,y_test=basic.prepare_data(X_test,y_test,n_channels) model_factory,params=models.get_model_factory(model_type) files.make_dir(out_path) for cat_i in range(n_cats): y_i=binarize(y_train,cat_i) model=model_factory(2,n_channels,params) model.summary() model.fit(X_train,y_i,epochs=n_epochs,batch_size=256) out_i=out_path+'/nn'+str(cat_i) model.save(out_i)
def train(in_path, out_path=None, n_epochs=1000, recon=True): (X_train, y_train), (X_test, y_test) = data.make_dataset(in_path) n_cats, n_channels = data.get_params(X_train, y_train) X = data.format_frames(X_train, n_channels) noise_X = add_noise(X) make_model, params = models.auto.get_model_factory("basic") model, recon = make_model(n_channels, params) recon.summary() gc.collect() recon.fit(noise_X, X, epochs=n_epochs, batch_size=256) #, # shuffle=True,validation_data=(X, X)) if (not out_path): dest_dir = os.path.split(in_path)[0] out_path = dest_dir + '/ae' model.save(out_path) if (recon): recon.save(out_path + "_recon")
def initiate_model(start_year, run_type='real_data'): """ Instantiate model class """ # get parameters todo: dit ook in path zetten? params = data.get_params() # load real patch data df_patch_data = data.get_patch_data(start_year) # get patchIDs patchIDs = df_patch_data.patchID.values # load patch availability df_patch_availability = data.get_patch_availability(start_year, patchIDs) # load environmental data df_env = data.get_environmental_data(start_year) # instantiate model model = OystercatcherModel(params, df_patch_data, df_patch_availability, df_env) return model
def loadPastNDays(nDays): params = get_params("parameters.json") params["back"] = [nDays, 'd'] print params selfStats = SelfSpy(params) # Get list of stats and create dict # RowId StartTime CreatedAt Duration Process WindowTitle keysPressed fields = selfStats.getKeysDict() measurement = "keys" tags = dict() all_data = list() for f in fields: data = dict() tag = dict() tag['processes'] = f['process'] data['measurement'] = measurement data['tags'] = tag data['time'] = f['started'] del f['started'] data['fields'] = f all_data.append(data) db_name = "selfspy" i = influx.Influx(db_name) i.create_database() print("Write json") print len(all_data) for d in all_data: print d ld = list() ld.append(d) i.write_json(ld)
def __init__(self, models): self.params = data.get_params()[0] self.models = models self.model = models[0] self.nr = 1 # Starting interactive matplotlib plot plt.ion() self.fig = plt.figure(figsize=(15, 10)) # Dividing matplotlib figure into three sections gs = GridSpec(4, 3) self.ax1 = plt.subplot(gs[:, :-1]) # self.ax1.yaxis.set_label_position("right") self.ax2 = plt.subplot(gs[-2:, -1]) self.ax3 = plt.subplot(gs[:-2, -1]) # Make grid, colorbar and text on grid self.cax1 = make_axes_locatable(self.ax1).append_axes("right", size="3%", pad="2%") self.fig.canvas.mpl_connect('pick_event', self.onpick) # self.gridtext = [ # self.ax1.text(i, j, int(self.model.grid[i, j].upslope), color='white', ha='center', va='center') # for i, j in zip(*self.grid.nonzero()) # ] # Define an action for modifying the line when any slider's value changes def sliders_on_changed(val): self.nr = int(val) self.model = self.models[self.nr - 1] self.update() # Define an axes area and draw a slider in it self.slider_ax = self.fig.add_axes([0.23, 0.03, 0.67, 0.03]) #, axisbg='blue') self.slider = Slider(self.slider_ax, 'Plot', 1, 24, valinit=self.nr, valfmt='%i') self.slider.on_changed(sliders_on_changed) def change_param(param): def fun(val): self.params[param] = val for model in models: model.params = self.params for cell in model.allVegetation: cell.update_params() return fun # Define an axes area and draw sliders in it params, _ = data.get_params() self.param_sliders = {} for i, param in enumerate( ['alpha', 'gamma', 'c_bb', 'c_rr', 'c_rb', 'c_br']): self.slider_ax = self.fig.add_axes( [0.05, 0.85 - 0.05 * i, 0.15, 0.03]) #, axisbg='blue') self.param_sliders[param] = Slider(self.slider_ax, param, 0, 1, valinit=params[param], valfmt='%.2f') self.param_sliders[param].on_changed(change_param(param))
for b in range(res): print("Simulation step %i for alpha %.2f gamma %.2f" % (b + 1, alpha, gamma)) # Update beta settings step_size = init_beta * 0.5**b for key in settings.keys(): old_beta, diff, cover = settings[key] new_beta = old_beta + np.sign(diff) * step_size settings[key] = (new_beta, diff, cover) # Set up procedure for both species for all plots proc = [] for cell_type in cell_types: # Initiate models without runoff return params, _ = data.get_params() params["alpha"] = alpha params["gamma"] = gamma models = [ model for model in initiate_models(params) if not model.runoff_return ] # Run models and collect differences for model in models: p = Process(target=evaluate_model, args=(model, settings, cell_type)) p.start() proc.append(p) # Run procedures in multi-processing
from datetime import datetime import pickle import sys from collections import defaultdict from multiprocessing import Process, Manager import numpy as np from model import Model from visualization import Visualize import data import matplotlib matplotlib.use('TkAgg') from matplotlib import pyplot as plt params_model, patch_shape = data.get_params() plots = data.get_plots() def initiate_models(params_model=params_model, double_seasonality=False, season_fact=1.0): cover_data = data.get_covers() models = [] for n, plot in enumerate(plots): seasonalities = data.get_seasonality(double_seasonality) for key in seasonalities[0].keys(): seasonalities[0][key] *= season_fact seasonalities[1][key] *= season_fact models.append( Model(n + 1, plot, params_model, patch_shape, seasonalities,
return if __name__ == '__main__': print('FITTING') artificial = False loc = '../results/' fname = input('What filename would you like to save the file under?: \n') comp_params = ['c_rr', 'c_bb', 'c_br', 'c_rb'] comp_ranges = [(0, .4), (0, .3), (0, 1), (0, 1)] glob_params = ['alpha', 'beta', 'gamma'] glob_ranges = [(0, .4), (0, .3), (0, 1)] seed_range = (0, .15) resolution = 10 params_model, _ = data.get_params() proc = [] for n in range(5): for i, (param, param_range) in enumerate(zip(comp_params, comp_ranges)): this_fname = "%s%s_%i_%s"%(loc, fname, n + 1, param) p = Process(target=minimize_total, args=(param, param_range, params_model, resolution, i + 2, artificial, this_fname)) p.start() proc.append(p) for p in proc: p.join() proc = [] for n in range(5): for i, (param, param_range) in enumerate(zip(glob_params, glob_ranges)):
def guess_parameters(self): for k, v in get_params(self.n_heavy_atoms, self.theory, self.program).items(): setattr(self, k, v)