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)
