def prepare(self): dataset = data() self.graph = dataset.loadGraph(self.params['graph'], string.atoi(self.params['dim'])) self.drawer = sampler(self.graph, self.Z) self.model = BPR_model(self.Z, self.drawer.user_set, self.drawer.item_set)
def prepare(self): dataset = data() self.userX, uf_num, self.uIDx = dataset.loadFeature(self.params['userX']) self.itemX, vf_num, self.vIDx = dataset.loadFeature(self.params['itemX']) self.graph = dataset.loadGraph(self.params['graph'], string.atoi(self.params['dim'])) self.drawer = sampler(self.graph, self.vIDx, vf_num, self.uIDx, float(self.params['sigma']), self.userX, self.itemX) self.model = RankPairFM_Model(string.atoi(self.params['k']), uf_num, vf_num, self.drawer.user_set, self.drawer.item_set) self.len_ux = len(self.userX) self.len_vx = len(self.itemX)
def run(): df_pre = prep() df_sampled = sampler(df_pre) # df_reduced_dims = reduction(df_sampled) # quick_grapher.graph(df_reduced_dims) # Model fitting with SVM #df_B = svc(df_sampled) df_C = KNN(df_sampled)
def prepare(self): dataset = data() self.graph = dataset.loadGraph(self.params['graph'], string.atoi(self.params['dim'])) self.drawer = sampler(self.graph, self.Z) itemX, vf_num, self.vIDx = dataset.loadFeature(self.params['itemX']) self.itemX = dataset.constructSparseMat(itemX, vf_num) self.model = MAP_BPR_Model(string.atoi(self.params['k']), self.drawer.user_set, self.drawer.item_set, vf_num)
def tttest(learner, args, train_envs, test_envs, log_dir): batch_sampler = sampler(args.batch_size) for i in range(args.num_updates): loss_outer = [] rew_rem = [] for j in range(1): s, a, r = batch_sampler.sample(train_envs[j], learner) inner_loss = learner.cal_loss(s, a, r) grads = torch.autograd.grad(inner_loss, learner.parameters()) grads = parameters_to_vector(grads) old_params = parameters_to_vector(learner.parameters()) vector_to_parameters(old_params - args.outer_lr * grads, learner.parameters()) mean_rew = torch.mean(r).data.numpy() rew_rem.append(mean_rew) print(np.mean(rew_rem))
def get_true_sample(get_point,batch_size,d_input_dim = 2): return sampler(get_point,batch_size)
pandas.DataFrame(groups).to_csv('groups_test.csv', header=False) #X = pandas.read_csv('/homedirec/user/X.csv', index_col=0) #y = pandas.read_csv('/homedirec/user/y.csv', index_col=0, header=None) #feat_names = list(X.columns)#if not list, can't pickle #groups = pandas.read_csv('/homedirec/user/groups.csv', index_col=0, header=None) #groups = range(len(y)) # feat_names = [] X = pandas.DataFrame(X) y = pandas.DataFrame(y) feat_names = list(X.columns)#if not list, can't pickle #X, y = datasets.make_classification(n_samples=100, n_features=10, weights=[0.93,0.07]) fname = args.op_dir + '/data_rs_' + str(args.random_state)+'.pickle' samp = args.samp if samp: print "Sampling--generating iid sample!" X, y, groups = sampler(X, y, groups, random_state=args.random_state) groups.columns = [1] # pdb.set_trace() sample_weights = [1 for el in groups[1]] weight = args.weight if weight==1: print "weighting samples" nhpid = get_nhosp_per_id(groups) sample_weights = [1/float(nhpid[el]) for el in groups[1]] print "sample weights head", sample_weights[0:10] sample_weights = np.array(sample_weights) X, y, groups = np.array(X), np.ravel(np.array(y)), np.array(groups)
] print("{:.4f}".format(fillList[len(fillList) - 1])) if varyL: print("\nA = {:4.2f}. Is that ok?".format(loc)) else: print("\nL = {:3d} and A = {:4.2f}. Is that ok?".format(L, loc)) print("Filename:", saveFilename) variedL, L, loc = sampler.everythingOK(variedL, L, loc) print("A = ", loc) print("L = ", L) time.sleep(1) sampler = sampler(Q, loc) print(variedL) # Check if all files are present for E, T, H, L, n, sizeInFilename, fillInFilename, fill in zip( Ex, temp, Hz, variedL, nList, Lname, fillName, fillList): # Check if all files are present before starting analysis for i in range(n): LName = "_L_" + str(L) if sizeInFilename else "" FName = "_fill_%.4f" % (fill) if fillInFilename else "" filename = dataLocation + str( i ) + LName + FName + filestruct + "{0:.5f}_Ex_{1:.5f}_T_{2:.5f}_run_0.dat".format( H, E, T) if isfile(filename) != True:
if not os.path.exists(RESULTS_FOLDER+"noise_%f/results_p%d" %(NOISE_VALUE,p)) : os.makedirs(RESULTS_FOLDER+"noise_%f/results_p%d" %(NOISE_VALUE,p)) #os.chdir("./results_p%d" %p) save_to_dir = RESULTS_FOLDER+"noise_%f/results_p%d/" %(NOISE_VALUE,p) #summary_array = np.zeros((REPEATS_PER_PARAMETER_SET, 10)) ## do no use this because some repeats may be missing! #for r in range(REPEATS_PER_PARAMETER_SET): file_list = glob.glob(RESULTS_FOLDER+'noise_%f/param_%d/*.dynamics' %(NOISE_VALUE,p)) results_array = np.zeros((len(file_list), 17 * NUMBER_OF_BINS)) f_id = 0 for file in file_list: S = sampler(NUMBER_OF_SAMPLES, file) S.sample() calc = timme_calculator(S, NUMBER_OF_BINS) results_array[f_id,:] = calc.calculate() f_id += 1 np.savetxt(save_to_dir + "param%d_sample%d_bin%d.timme_fit" %(p,NUMBER_OF_SAMPLES,NUMBER_OF_BINS), results_array, delimiter=',') #os.chdir("../")
def main(): parser = argparse.ArgumentParser( description='Train Unsupervised Blending GAN') parser.add_argument('--nz', type=int, default=100, help='Size of the latent z vector') parser.add_argument('--ngf', type=int, default=64, help='# of base filters in G') parser.add_argument('--ndf', type=int, default=64, help='# of base filters in D') parser.add_argument('--nc', type=int, default=3, help='# of output channels in G') parser.add_argument('--load_size', type=int, default=64, help='Scale image to load_size') parser.add_argument( '--image_size', type=int, default=64, help='The height / width of the input image to network') parser.add_argument('--gpu', type=int, default=0, help='GPU ID (negative value indicates CPU)') parser.add_argument('--lr_d', type=float, default=0.00005, help='Learning rate for Critic, default=0.00005') parser.add_argument('--lr_g', type=float, default=0.00005, help='Learning rate for Generator, default=0.00005') parser.add_argument('--d_iters', type=int, default=5, help='# of D iters per each G iter') parser.add_argument('--n_epoch', type=int, default=25, help='# of epochs to train for') parser.add_argument('--clamp_lower', type=float, default=-0.01, help='Lower bound for clipping') parser.add_argument('--clamp_upper', type=float, default=0.01, help='Upper bound for clipping') parser.add_argument('--data_root', help='Path to dataset') parser.add_argument('--experiment', default='Wasserstein_GAN_result', help='Where to store samples and models') parser.add_argument('--workers', type=int, default=10, help='# of data loading workers') parser.add_argument('--batch_size', type=int, default=128, help='input batch size') parser.add_argument('--test_size', type=int, default=64, help='Batch size for testing') parser.add_argument('--manual_seed', type=int, default=5, help='Manul seed') parser.add_argument('--resume', default='', help='Resume the training from snapshot') parser.add_argument('--snapshot_interval', type=int, default=1, help='Interval of snapshot (epoch)') parser.add_argument('--print_interval', type=int, default=1, help='Interval of printing log to console (iteration)') parser.add_argument('--plot_interval', type=int, default=10, help='Interval of plot (iteration)') args = parser.parse_args() random.seed(args.manual_seed) print('Input arguments:') for key, value in vars(args).items(): print('\t{}: {}'.format(key, value)) print('') # Set up G & D print('Create & Init models ...') print('\tInit G network ...') G = DCGAN_G(args.image_size, args.nc, args.ngf, init_conv, init_bn) print('\tInit D network ...') D = DCGAN_D(args.image_size, args.ndf, 1, init_conv, init_bn) if args.gpu >= 0: print('\tCopy models to gpu {} ...'.format(args.gpu)) chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current G.to_gpu() # Copy the model to the GPU D.to_gpu() print('Init models done ...\n') # Setup an optimizer optimizer_d = make_optimizer(D, args.lr_d) optimizer_g = make_optimizer(G, args.lr_g) ######################################################################################################################## # Setup dataset & iterator print('Load images from {} ...'.format(args.data_root)) trainset = H5pyDataset(args.data_root, load_size=args.load_size, crop_size=args.image_size) print('\tTrainset contains {} image files'.format(len(trainset))) print('') train_iter = chainer.iterators.MultiprocessIterator( trainset, args.batch_size, n_processes=args.workers, n_prefetch=args.workers) ######################################################################################################################## # Set up a trainer updater = WassersteinUpdater(models=(G, D), args=args, iterator=train_iter, optimizer={ 'main': optimizer_g, 'D': optimizer_d }, device=args.gpu) trainer = training.Trainer(updater, (args.n_epoch, 'epoch'), out=args.experiment) # Snapshot snapshot_interval = (args.snapshot_interval, 'epoch') trainer.extend( extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object(G, 'g_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object(D, 'd_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) # Display print_interval = (args.print_interval, 'iteration') trainer.extend(extensions.LogReport(trigger=print_interval)) trainer.extend(extensions.PrintReport( ['iteration', 'main/loss', 'D/loss', 'D/loss_real', 'D/loss_fake']), trigger=print_interval) trainer.extend(extensions.ProgressBar(update_interval=args.print_interval)) trainer.extend(extensions.dump_graph('D/loss', out_name='TrainGraph.dot')) # Plot plot_interval = (args.plot_interval, 'iteration') trainer.extend(extensions.PlotReport(['main/loss'], 'iteration', file_name='loss.png', trigger=plot_interval), trigger=plot_interval) trainer.extend(extensions.PlotReport(['D/loss'], 'iteration', file_name='d_loss.png', trigger=plot_interval), trigger=plot_interval) trainer.extend(extensions.PlotReport(['D/loss_real'], 'iteration', file_name='loss_real.png', trigger=plot_interval), trigger=plot_interval) trainer.extend(extensions.PlotReport(['D/loss_fake'], 'iteration', file_name='loss_fake.png', trigger=plot_interval), trigger=plot_interval) # Eval path = os.path.join(args.experiment, 'samples') if not os.path.isdir(path): os.makedirs(path) print('Saving samples to {} ...\n'.format(path)) noisev = Variable( np.asarray(np.random.normal(size=(args.test_size, args.nz, 1, 1)), dtype=np.float32)) noisev.to_gpu(args.gpu) trainer.extend(sampler(G, path, noisev, 'fake_samples_{}.png'), trigger=plot_interval) if args.resume: # Resume from a snapshot print('Resume from {} ... \n'.format(args.resume)) chainer.serializers.load_npz(args.resume, trainer) # Run the training print('Training start ...\n') trainer.run()
def prepare(self): self.dataset = data() self.test_set = self.dataset.loadGraph(self.params['test_set'], string.atoi(self.params['dim']), False) self.test_pairs = self.dataset.loadGraph(self.params['test_pairs'], string.atoi(self.params['dim']), False) self.drawer = sampler(self.test_pairs, string.atoi(self.params['k']))
def main(): parser = argparse.ArgumentParser(description='Train Blending GAN') parser.add_argument('--nef', type=int, default=64, help='# of base filters in encoder') parser.add_argument('--ngf', type=int, default=64, help='# of base filters in decoder') parser.add_argument('--nc', type=int, default=3, help='# of output channels in decoder') parser.add_argument('--nBottleneck', type=int, default=4000, help='# of output channels in encoder') parser.add_argument('--ndf', type=int, default=64, help='# of base filters in D') parser.add_argument('--lr_d', type=float, default=0.0002, help='Learning rate for Critic, default=0.0002') parser.add_argument('--lr_g', type=float, default=0.002, help='Learning rate for Generator, default=0.002') parser.add_argument('--beta1', type=float, default=0.5, help='Beta for Adam, default=0.5') parser.add_argument('--l2_weight', type=float, default=0.999, help='Weight for l2 loss, default=0.999') parser.add_argument('--gpu', type=int, default=0, help='GPU ID (negative value indicates CPU)') parser.add_argument('--n_epoch', type=int, default=25, help='# of epochs to train for') parser.add_argument('--data_root', help='Path to dataset') parser.add_argument('--load_size', type=int, default=64, help='Scale image to load_size') parser.add_argument( '--image_size', type=int, default=64, help='The height / width of the input image to network') parser.add_argument('--ratio', type=float, default=0.5, help='Ratio for center square size v.s. image_size') parser.add_argument('--val_ratio', type=float, default=0.05, help='Ratio for validation set v.s. data set') parser.add_argument('--d_iters', type=int, default=5, help='# of D iters per each G iter') parser.add_argument('--clamp_lower', type=float, default=-0.01, help='Lower bound for clipping') parser.add_argument('--clamp_upper', type=float, default=0.01, help='Upper bound for clipping') parser.add_argument('--experiment', default='encoder_decoder_blending_result', help='Where to store samples and models') parser.add_argument('--test_folder', default='samples', help='Where to store test results') parser.add_argument('--workers', type=int, default=10, help='# of data loading workers') parser.add_argument('--batch_size', type=int, default=64, help='Input batch size') parser.add_argument('--test_size', type=int, default=64, help='Batch size for testing') parser.add_argument('--train_samples', type=int, default=150000, help='# of training examples') parser.add_argument('--test_samples', type=int, default=256, help='# of testing examples') parser.add_argument('--manual_seed', type=int, default=5, help='Manul seed') parser.add_argument('--resume', default='', help='Resume the training from snapshot') parser.add_argument('--snapshot_interval', type=int, default=1, help='Interval of snapshot (epochs)') parser.add_argument('--print_interval', type=int, default=1, help='Interval of printing log to console (iteration)') parser.add_argument('--plot_interval', type=int, default=10, help='Interval of plot (iteration)') args = parser.parse_args() random.seed(args.manual_seed) print('Input arguments:') for key, value in vars(args).items(): print('\t{}: {}'.format(key, value)) print('') # Set up G & D print('Create & Init models ...') print('\tInit G network ...') G = EncoderDecoder(args.nef, args.ngf, args.nc, args.nBottleneck, image_size=args.image_size, conv_init=init_conv, bn_init=init_bn) print('\tInit D network ...') D = DCGAN_D(args.image_size, args.ndf, conv_init=init_conv, bn_init=init_bn) if args.gpu >= 0: print('\tCopy models to gpu {} ...'.format(args.gpu)) chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current G.to_gpu() # Copy the model to the GPU D.to_gpu() print('Init models done ...\n') # Setup an optimizer optimizer_d = make_optimizer(D, args.lr_d, args.beta1) optimizer_g = make_optimizer(G, args.lr_g, args.beta1) ######################################################################################################################## # Setup dataset & iterator print('Load images from {} ...'.format(args.data_root)) folders = sorted([ folder for folder in os.listdir(args.data_root) if os.path.isdir(os.path.join(args.data_root, folder)) ]) val_end = int(args.val_ratio * len(folders)) print('\t{} folders in total, {} val folders ...'.format( len(folders), val_end)) trainset = BlendingDataset(args.train_samples, folders[val_end:], args.data_root, args.ratio, args.load_size, args.image_size) valset = BlendingDataset(args.test_samples, folders[:val_end], args.data_root, args.ratio, args.load_size, args.image_size) print('\tTrainset contains {} image files'.format(len(trainset))) print('\tValset contains {} image files'.format(len(valset))) print('') train_iter = chainer.iterators.MultiprocessIterator( trainset, args.batch_size, n_processes=args.workers, n_prefetch=args.workers) ######################################################################################################################## # Set up a trainer updater = EncoderDecoderBlendingUpdater(models=(G, D), args=args, iterator=train_iter, optimizer={ 'main': optimizer_g, 'D': optimizer_d }, device=args.gpu) trainer = training.Trainer(updater, (args.n_epoch, 'epoch'), out=args.experiment) # Snapshot snapshot_interval = (args.snapshot_interval, 'epoch') trainer.extend( extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object(G, 'g_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.snapshot_object(D, 'd_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) # Display print_interval = (args.print_interval, 'iteration') trainer.extend(extensions.LogReport(trigger=print_interval)) trainer.extend(extensions.PrintReport( ['iteration', 'main/loss', 'D/loss', 'main/l2_loss']), trigger=print_interval) trainer.extend(extensions.ProgressBar(update_interval=args.print_interval)) trainer.extend(extensions.dump_graph('D/loss', out_name='TrainGraph.dot')) # Plot plot_interval = (args.plot_interval, 'iteration') trainer.extend(extensions.PlotReport(['main/loss'], 'iteration', file_name='loss.png', trigger=plot_interval), trigger=plot_interval) trainer.extend(extensions.PlotReport(['D/loss'], 'iteration', file_name='d_loss.png', trigger=plot_interval), trigger=plot_interval) trainer.extend(extensions.PlotReport(['main/l2_loss'], 'iteration', file_name='l2_loss.png', trigger=plot_interval), trigger=plot_interval) # Eval path = os.path.join(args.experiment, args.test_folder) if not os.path.isdir(path): os.makedirs(path) print('Saving samples to {} ...\n'.format(path)) train_batch = [trainset[idx][0] for idx in range(args.test_size)] train_v = Variable(chainer.dataset.concat_examples(train_batch, args.gpu), volatile='on') trainer.extend(sampler(G, path, train_v, 'fake_samples_train_{}.png'), trigger=plot_interval) val_batch = [valset[idx][0] for idx in range(args.test_size)] val_v = Variable(chainer.dataset.concat_examples(val_batch, args.gpu), volatile='on') trainer.extend(sampler(G, path, val_v, 'fake_samples_val_{}.png'), trigger=plot_interval) if args.resume: # Resume from a snapshot print('Resume from {} ... \n'.format(args.resume)) chainer.serializers.load_npz(args.resume, trainer) # Run the training print('Training start ...\n') trainer.run()
#samples = range(500,50500,500) #samples = range(50,5050,50) #samples = np.logspace(2,15,num=14,base=2) #samples = samples.astype(int) samples = range(3, 20) a = parameters[p, 1] b = parameters[p, 2] c = parameters[p, 3] x00 = parameters[p, 13] x10 = parameters[p, 14] T2P = parameters[p, 12] print "b = ", -b for si in samples: ls = linear_simulator(a, b, c, x00, x10, DT, T2P, noise, False) ls.run() D = ls.get_dynamics() S = sampler(si, D) S.sample() calc = timme_calculator(S, NUMBER_OF_BINS) results, err = calc.calculate() results = results[0:6] print(results[2]) #print(S.sampled_dynamics)
def test(learner, args, train_envs, test_envs, log_dir): learner_test = network(args.num_layers, args.num_hidden, args.num_bandits) batch_sampler = sampler(args.batch_size, args.num_bandits) max_kl = args.max_kl cg_iters = args.cg_iters cg_damping = args.cg_damping ls_max_steps = args.ls_max_steps ls_backtrack_ratio = args.ls_backtrack_ratio train_rew = [] for i in range(args.num_updates): #print(i) adapt_params = [] inner_losses = [] adapt_episodes = [] rew_rem = [] for j in range(args.num_tasks_train): e = batch_sampler.sample(train_envs[j], learner) inner_loss = learner.cal_loss(e.s, e.a, e.r) params = learner.update_params(inner_loss, args.inner_lr, args.first_order) a_e = batch_sampler.sample(train_envs[j], learner, params) adapt_params.append(params) adapt_episodes.append(a_e) inner_losses.append(inner_loss) mean_rew = torch.mean(a_e.r).data.numpy() rew_rem.append(mean_rew) print(np.mean(rew_rem)) train_rew.append(np.mean(rew_rem)) old_loss, _, old_pis = learner.surrogate_loss(adapt_episodes, inner_losses) grads = torch.autograd.grad(old_loss, learner.parameters(), retain_graph=True) grads = parameters_to_vector(grads) # Compute the step direction with Conjugate Gradient hessian_vector_product = learner.hessian_vector_product( adapt_episodes, inner_losses, damping=cg_damping) stepdir = conjugate_gradient(hessian_vector_product, grads, cg_iters=cg_iters) # Compute the Lagrange multiplier shs = 0.5 * torch.dot(stepdir, hessian_vector_product(stepdir)) lagrange_multiplier = torch.sqrt(shs / max_kl) step = stepdir / lagrange_multiplier # Save the old parameters old_params = parameters_to_vector(learner.parameters()) # Line search step_size = 1.0 for _ in range(ls_max_steps): vector_to_parameters(old_params - step_size * step, learner.parameters()) loss, kl, _ = learner.surrogate_loss(adapt_episodes, inner_losses, old_pis=old_pis) improve = loss - old_loss if (improve.item() < 0.0) and (kl.item() < max_kl): break step_size *= ls_backtrack_ratio else: vector_to_parameters(old_params, learner.parameters()) if (i + 1) % 10 == 0: test_input = torch.FloatTensor([[1]]) test_output = learner.forward(test_input).data.numpy()[0] plt.figure() plt.bar(np.arange(len(test_output)), test_output) plt.savefig(log_dir + 'figures/before%i.png' % i) plt.close() for j in range(args.num_tasks_train): test_output = learner.forward(test_input, adapt_params[j]).data.numpy()[0] plt.figure() plt.bar(np.arange(len(test_output)), test_output) plt.savefig(log_dir + 'figures/after%i_%i.png' % (j, i)) plt.close() np.save(log_dir + 'train_rew' + str(args.inner_lr) + '.npy', train_rew) plt.figure() plt.plot(train_rew) plt.show() plt.figure() plt.plot(train_rew) plt.savefig(log_dir + 'train_rew.png') return
c = parameters[pi,3] d = parameters[pi,4] x00 = parameters[pi,14] x10 = parameters[pi,15] T2P = parameters[pi,13] ls = hollingII_simulator(a, b, c,d, x00, x10, DT, T2P, noise, plot_dynamics) ls.run() D = ls.get_dynamics() E_prey = np.asarray(ls.ext_prey) E_pred = np.asarray(ls.ext_pred) ## now do inference: S = sampler(si, D) S.sample() calc = timme_calculator(S, NUMBER_OF_BINS) results, err = calc.calculate() results = results[0:6] results = np.append(results, err[0]) results = np.append(results, err[1]) x0 = D[1,:] # prey time series x1 = D[2,:] # prey time series L = np.ones(len(x0)) a00 = np.mean(-a*L + b*x1/((x0+d)**2)) ## equala to \alpha_{00} a01 = np.mean(-b/(x0+d) ) ## equala to \alpha_{00} a10 = np.mean(c*d/((x0+d)**2)) ## equala to \alpha_{00}
#def train(args): sp = spm.SentencePieceProcessor() sp.Load("m3k.model") sp_vocab = {sp.IdToPiece(i): i for i in range(sp.GetPieceSize())} inv_sp_vocab = {value: key for key, value in sp_vocab.items()} vocab = collections.defaultdict(lambda: len(vocab)) batch_size = 10 sequence_len = 200 #250#1601 #n_docs = 1063180 input_len = 35 #train_vectorizer=infinite_vectorizer(sp_vocab, DATA_PATH, batch_size, sequence_len, sp_model=sp) train_vectorizer = sampler(sp, vocab, input_len=input_len, output_len=sequence_len) examples = [next(train_vectorizer) for i in range(10)] example_input = [ np.concatenate([inp[0] for inp, outp in examples]), np.concatenate([inp[1] for inp, outp in examples]) ] example_output = np.concatenate([outp for inp, outp in examples]) generation_model = GenerationModel(len(sp_vocab), input_len, sequence_len, args) #from keras.utils import multi_gpu_model #para_model=multi_gpu_model(generation_model.model, gpus=4)
b = parameters[pi,2] c = parameters[pi,3] x00 = parameters[pi,13] x10 = parameters[pi,14] T2P = parameters[pi,12] ls = linear_simulator(a, b, c, x00, x10, DT, T2P, ni, plot_dynamics) ls.run() D = ls.get_dynamics() E_prey = np.asarray(ls.ext_prey) E_pred = np.asarray(ls.ext_pred) ## now do inference: S = sampler(NUMBER_OF_SAMPLES, D) S.sample() calc = timme_calculator(S, NUMBER_OF_BINS) results, err = calc.calculate() results = results[0:6] results = np.append(results, err[0]) results = np.append(results, err[1]) ## calculate relative error: re = [] re.append(np.abs((results[0]-a)/a)) re.append(np.abs((results[1]+a)/a)) re.append(np.abs((results[2]+b)/b)) re.append(np.abs((results[3]+1)/1.0)) re.append(np.abs((results[4]-c)/c)) re.append(np.abs(results[5]))
G0[1, :] = binned_data[1, :] * binned_data[1, :] G0[2, :] = binned_data[1, :] * binned_data[2, :] X1 = binned_data[4, :] G1 = np.zeros((3, M)) G1[0, :] = binned_data[2, :] G1[1, :] = binned_data[2, :] * binned_data[1, :] G1[2, :] = binned_data[2, :] * binned_data[2, :] J0 = np.dot(np.dot(X0, np.transpose(G0)), np.linalg.inv(np.dot(G0, np.transpose(G0)))) J1 = np.dot(np.dot(X1, np.transpose(G1)), np.linalg.inv(np.dot(G1, np.transpose(G1)))) J = np.asarray([J0, J1]) # print("shape of J = ") # print(np.shape(J)) return J # print(J0) # print(J1) if __name__ == "__main__": S = sampler(100, "example_run.dynamics", "example_prey.extinctions", "example_pred.extinctions") S.sample() calc = timme_calculator(S, 2) calc.calculate() # calc.binning(np.asarray([[1,2,3,4,5,6,7,8, 9],[1, 7, 5, 3, 4, 6, 2, 8, 9], [1, 7, 5, 3, 4, 6, 2, 8, 9]])) # testing # calc.bin_stats()
J0 = np.dot(np.dot(X0, np.transpose(G0)), np.linalg.inv(np.dot(G0, np.transpose(G0)))) J1 = np.dot(np.dot(X1, np.transpose(G1)), np.linalg.inv(np.dot(G1, np.transpose(G1)))) J = np.asarray([J0, J1]) # evaluate error function: err = (np.sum(np.abs(X0 - np.dot(J0, G0))), np.sum(np.abs(X1 - np.dot(J1, G1)))) #print("shape of J = ") #print(np.shape(J)) return (J, err) #print(J0) #print(J1) if __name__ == '__main__': S = sampler(100, 'example_run.dynamics', 'example_prey.extinctions', 'example_pred.extinctions') S.sample() calc = timme_calculator(S, 1) result = calc.calculate() print(result) #calc.binning(np.asarray([[1,2,3,4,5,6,7,8, 9],[1, 7, 5, 3, 4, 6, 2, 8, 9], [1, 7, 5, 3, 4, 6, 2, 8, 9]])) # testing #calc.bin_stats()
J1 =np.dot( np.dot(X1, np.transpose(G1)), np.linalg.inv (np.dot(G1, np.transpose(G1)))) J = np.asarray([J0,J1]) # evaluate error function: err = (np.sum(np.abs(X0 - np.dot(J0,G0))), np.sum(np.abs(X1 - np.dot(J1,G1)))) #print("shape of J = ") #print(np.shape(J)) return (J, err) #print(J0) #print(J1) if __name__=='__main__': S = sampler(100, 'example_run.dynamics', 'example_prey.extinctions', 'example_pred.extinctions') S.sample() calc = timme_calculator(S, 1) result = calc.calculate() print(result) #calc.binning(np.asarray([[1,2,3,4,5,6,7,8, 9],[1, 7, 5, 3, 4, 6, 2, 8, 9], [1, 7, 5, 3, 4, 6, 2, 8, 9]])) # testing #calc.bin_stats()