def plot_topo(fnm, fnm2=None, show=True, savefig=False): params, par_names = get_params() data = np.loadtxt(fnm) print np.shape(data) if fnm2 is not None: data2 = np.loadtxt(fnm2) print np.shape(data2) mpl.rcParams['figure.figsize'] = 15, 12 mpl.rcParams['font.size'] = 10 n = len(par_names) f, axarr = plt.subplots(n, n) fitness = data[:, 0] print np.min(fitness), np.max(fitness) fitness = np.log(fitness[~np.isnan(fitness)]) print np.shape(fitness) print np.min(fitness), np.max(fitness) j = 0 for v in par_names: i = 0 for p in par_names: if (j < i): px = data[:, i + 1] py = data[:, j + 1] px = px[~np.isnan(fitness)] py = py[~np.isnan(fitness)] xi = np.linspace(min(px), max(px), 100) yi = np.linspace(min(py), max(py), 100) zi = griddata(px, py, fitness, xi, yi) p = axarr[i, j].pcolormesh(xi, yi, zi, cmap='Paired') if fnm2 is not None: px2 = data2[:, i + 2] py2 = data2[:, j + 2] axarr[i, j].plot(px2, py2, 'ko-', alpha=0.5, mew=0.1) axarr[i, j].plot(px2[-1], py2[-1], 'rs', markersize=7) axarr[i, j].set_xlabel(par_names[i]) axarr[i, j].set_ylabel(par_names[j]) axarr[i, j].set_xlim(float(params[i][1]), float(params[i][2])) axarr[i, j].set_ylim(float(params[j][1]), float(params[j][2])) if i == 1: divider = make_axes_locatable(axarr[0, 1]) cax = divider.append_axes("left", size="10%", pad=0.1) cb = plt.colorbar(p, cax=cax) cb.set_label("Fitness", fontsize=12) else: f.delaxes(axarr[i, j]) plt.setp(axarr[i, j].get_xticklabels(), rotation=30) i += 1 j += 1 f.set_tight_layout(True) if show: plt.show() if savefig: f.savefig('parameter_matrix.pdf', type='PDF', bbox_inches='tight', pad_inches=0.0)
def plot_topo(fnm,fnm2=None,show=True,savefig=False): params, par_names = get_params() data = np.loadtxt(fnm) print np.shape(data) if fnm2 is not None: data2 = np.loadtxt(fnm2) print np.shape(data2) mpl.rcParams['figure.figsize'] = 15,12 mpl.rcParams['font.size'] = 10 n = len(par_names) f, axarr = plt.subplots(n,n) fitness = data[:,0] print np.min(fitness), np.max(fitness) fitness = np.log(fitness[~np.isnan(fitness)]) print np.shape(fitness) print np.min(fitness), np.max(fitness) j = 0 for v in par_names: i = 0 for p in par_names: if (j < i): px = data[:,i+1] py = data[:,j+1] px = px[~np.isnan(fitness)] py = py[~np.isnan(fitness)] xi = np.linspace(min(px), max(px),100) yi = np.linspace(min(py), max(py),100) zi = griddata(px, py, fitness, xi, yi) p = axarr[i,j].pcolormesh(xi,yi,zi,cmap='Paired') if fnm2 is not None: px2 = data2[:,i+2] py2 = data2[:,j+2] axarr[i,j].plot(px2,py2,'ko-',alpha=0.5,mew=0.1) axarr[i,j].plot(px2[-1],py2[-1],'rs',markersize=7) axarr[i,j].set_xlabel(par_names[i]) axarr[i,j].set_ylabel(par_names[j]) axarr[i,j].set_xlim(float(params[i][1]),float(params[i][2])) axarr[i,j].set_ylim(float(params[j][1]),float(params[j][2])) if i == 1 : divider = make_axes_locatable(axarr[0,1]) cax = divider.append_axes("left", size="10%", pad=0.1) cb = plt.colorbar(p,cax=cax) cb.set_label("Fitness",fontsize=12) else: f.delaxes(axarr[i,j]) plt.setp(axarr[i,j].get_xticklabels(), rotation=30) i += 1 j += 1 f.set_tight_layout(True) if show: plt.show() if savefig: f.savefig('parameter_matrix.pdf',type='PDF',bbox_inches='tight', pad_inches = 0.0)
def plot_costs(fnm, show=True, savefig=False): params, par_names = get_params() print params data = np.loadtxt(fnm, unpack=True) mpl.rcParams['figure.figsize'] = 15, 12 mpl.rcParams['font.size'] = 10 n = len(par_names) f, axarr = plt.subplots(n, n) j = 0 for v in par_names: i = 0 for p in par_names: if (j < i): px = data[i + 2, :] py = data[j + 2, :] axarr[i, j].plot(px, py, 'ko-', alpha=0.1, mew=0) axarr[i, j].plot(px[-1], py[-1], 'rs', alpha=0.5, markersize=7, mew=0) axarr[i, j].set_xlabel(par_names[i]) axarr[i, j].set_ylabel(par_names[j]) axarr[i, j].set_xlim(float(params[i][1]), float(params[i][2])) axarr[i, j].set_ylim(float(params[j][1]), float(params[j][2])) else: f.delaxes(axarr[i, j]) plt.setp(axarr[i, j].get_xticklabels(), rotation=30) i += 1 j += 1 f.set_tight_layout(True) if show: plt.show() if savefig: f.savefig('parameter_matrix.pdf', type='PDF', bbox_inches='tight', pad_inches=0.0)
# mse is mean_squared_error, mpe is mean_absolute_percentage_error model.compile(loss='mean_squared_error', optimizer='adam', metrics=['mse','mape']) # Here we're starting our training history=model.fit(train_x, train_y, verbose=2, epochs=epochs, batch_size=batches) return model, name, mparams, history if __name__ == '__main__': # Getting data formatted as a supervised problem years, past_values, values=get_data() X, Y = past_values, values # Split data into two parts: one for training, one for testing # Test part won't be seen by a model during training so it will # give us some idea how our model performs on a unseen data. train_x, train_y, test_x, test_y = train_test_split(X, Y) # Getting our command line parameters name, epochs, batches, plot=get_params() # Do the training model, name, mp, history=train_model(name, train_x, train_y, epochs, batches) # Save models and the training history for later use mname='models/model-%s-%d-%d' % (name, epochs, batches) model.save(mname+'.h5') with open(mname+'-history.pickle', 'wb') as ms: pickle.dump(history.history, ms) print() print('Model and its history saved in %s*' % mname) title='%s (epochs=%d, batch_size=%d)' % (name, epochs, batches) # Test our model on both data that has been seen # (training data set) and unseen (test data set) print('Scores for %s' % title) train_score = model.evaluate(train_x, train_y, verbose=0) trscore='RMSE: %s MAPE: %.0f%%' % ("{:,.0f}".format(math.sqrt(train_score[0])), train_score[2])
logging.info("Epoch {} took {}".format(e, end - start_epoch)) logging.info("Epoch:{} ValidAccPi loss:{}".format( e, acc_ploss / it)) logging.info("Epoch:{} ValidAccValue loss: {}".format( e, acc_vloss / it)) logging.info("Epoch:{} ValidTotal loss:{}".format(e, acc_loss / it)) logging.info("Epoch:{} checkpoint".format(new_param_file)) torch.save({ 'state_dict': model.state_dict(), }, new_param_file) # saving new parameters logging.info("Training took {}".format(end - start_train)) logging.info("Saving model to {}".format(new_param_file)) torch.save({ 'state_dict': model.state_dict(), }, new_param_file) logging.info("####################END#################") return True if __name__ == "__main__": param_file = tools.get_params() new_param_file = tools.get_new_params() data_files = tools.get_data() if train(param_file, new_param_file, data_files): print("New model parameters were saved to {}".format(new_param_file)) else: print("Training failed, check for errors {}/train_{}.log".format( LOG_PATH, new_param_file))
recv_chips = np.zeros(2*RECV_CHIPS_I.shape[0], dtype=np.float) recv_chips[::2] = RECV_CHIPS_I[:,phi_idx] recv_chips[1::2] = RECV_CHIPS_Q[:,phi_idx] # slice bits to simulate hard decision decoder if decision in ('hard',): recv_chips = np.sign(recv_chips) recv_syms = pt.detect_syms_corrcoef(recv_chips)[1:-1] ser_s = np.append(ser_s, np.sum(recv_syms != send_syms_s) / (1.0*len(recv_syms))) if SER_S is None: SER_S = ser_s else: SER_S = np.vstack((SER_S, ser_s)) print 'PRR = ', np.mean((1-ser_s)**pktlen) np.save('data/ser_s_%s_%s_%s.npy'%(content, decision, mode), SER_S) if __name__ == '__main__': input_params = (('content', ('same', 'unif'), 'Data content'), ('decision', ('hard', 'soft'), 'Bit decision')) content, decision = tools.get_params(input_params) if not tools.overwrite_ok('data/ser_s_%s_%s_n.npy'%(content, decision)): sys.exit() gen_n_interf(mode='n') gen_n_interf(mode='1')
import numpy as np import matplotlib.pyplot as plt from tools import get_params, get_filenames, sort_key Tc = 2 / np.log(1 + np.sqrt(2)) lw = 3 c = ['indianred', 'orange', 'forestgreen', 'royalblue'] fig, ax = plt.subplots(figsize=(10, 8)) for filename in get_filenames('test_scalar'): b, L, K = get_params(filename) results = np.loadtxt(filename, unpack=True) temp = results[1] mse = results[6] i = int(np.log(L) / np.log(b) - 3) ax.semilogy(temp / Tc, mse, label="L=" + str(L), color=c[i], linewidth=lw) # sort legend handles, labels = ax.get_legend_handles_labels() labels, handles = zip(*sorted(zip(labels, handles), key=sort_key)) ax.legend(handles, labels) # fig params plt.ylabel('Mean Squared Error') plt.xlim(temp[0] / Tc, temp[-1] / Tc) plt.xlabel(r'$T/T_c$') plt.title('Testing MSE of Outputs From Large and Small Lattices')
break mcts_second.simulate(sims_second) pi = mcts_second.get_prob() move = pi.argmax() mcts_first.make_move(move) mcts_second.make_move(move) if mcts_first.winner != -1: logging.info("Game ended in {} moves".format(i)) break return if __name__ == "__main__": param_best = tools.get_params() param_latest = tools.get_versus() if param_best == None: print("Parameters were not found") sys.exit(1) if param_latest == None: print("Parameters were not found") sys.exit(1) print(param_best, param_latest) if param_best == param_latest: print("Best and latest are the same") sys.exit(1) rc = True try: rc = eval_models(param_best, param_latest)
#import conf conf = tf.compat.v1.ConfigProto() from keras.models import Sequential, load_model from keras.layers import Dense from prep import get_data from plot import plotpred from tools import get_params from train import confs import numpy as np import os if __name__ == '__main__': name, epochs, batches, _ = get_params(script='predict.py') model, _ = confs[name] mname = 'models/model-%s-%d-%d.h5' % (name, epochs, batches) # Loading the model. if os.path.exists(mname): model = load_model(mname) print('Model loaded!') else: print("Can't find %s model, train it first using 'train.py %s %d %d'" % (mname, name, epochs, batches)) years, _, values = get_data() # We're using the last value of our dataset # as a base for prediction. values, years = list(values), list(years) predict_on_value = values[-1:] predict_for_year = years[-1] + 'next'
df = format_cols(df) # Round the ESS to the nearest 10 df["n_eff"] = df["n_eff"].astype(int) // 100 * 100 # Tidy up column and row names for tex df = rename_cols(df) df = rename_rows(df) df = df.rename_axis('{Parameter}', axis=1) # Column formatting. The S column type is provided by siunitx col_format = "@{}cS[table-format=2.2]S[table-format=2.2]S[table-format=2.2]r@{}" # Print dataframe to latex tex = df.to_latex(escape=False, column_format=col_format) save_path = path.join(proj_dir, 'out', '{}'.format(model_name)) with open(save_path + '.tab', "w") as file: file.write(tex) if __name__ == "__main__": model_name = input("Name of model to fit (neg_bin or norm): ") param_names, plot_labels = tools.get_params(model_name) model, fit = tools.load_model_fit(model_name, proj_dir) fit2latex(fit, model_name, param_names, proj_dir)
del memory[-1] f.write("%i %.6g " % (iter, best["fitness"])) [f.write("%.6g "%p) for p in best["pos"]] f.write("\n") print " > iteration %i, fitness=%.4g" % (iter, best["fitness"]) print [names[i] + ": %.6g " % p for i,p in enumerate(best["pos"])] except KeyboardInterrupt: print "\033[91mInterruption by user. Exiting...\033[0m" pass f.close() return best if __name__ == "__main__": params, names = get_params() # # Parsing command line arguments # search_space = [[float(x) for x in p[1:]] for p in params] def plot(args,fnm): if args.plot: pc.plot_costs(fnm) if args.save and args.plot: pc.plot_costs(fnm,savefig=True) if args.save and not args.plot: pc.plot_costs(fnm,show=False,savefig=True) def run_es(args): max_gens = args.max_gens
p["pos"] = sample[i] return population def search(search_space, pop_size, prefix): f, tmpdir = init_search(prefix,names) #pop = init_population_random(search_space, pop_size) pop = init_population_lhs(search_space, pop_size) try: cost = run_particles(pop,tmpdir+'/'+prefix) for i,candidate in enumerate(pop): candidate["cost"] = cost[candidate["id"]] f.write("%.6g " % candidate["cost"]) [f.write("%.6g "%p) for p in candidate["pos"]] f.write("\n") #print candidate["pos"] except KeyboardInterrupt: print "\033[91mInterruption by user. Exiting...\033[0m" pass f.close() if __name__ == "__main__": #Get information on parameters and ranges from user file params, names = get_params() search_space = [[float(x) for x in p[1:]] for p in params] search(search_space, 1000, 'topo_')
def main(): global args args = get_args() print("DBG:Play: starting server") server = Server(args.ip, args.port) mcts = cmcts.mcts() param_file = tools.get_params() params = torch.load(param_file, map_location='cpu') model_class = getattr(model_module, MODEL_CLASS) model = model_class() model.load_state_dict(params['state_dict']) print(param_file) jit_model_name = "{}/tmp_{}.pt".format( os.path.dirname(os.path.realpath(__file__)), os.path.basename(param_file).replace(".pyt", '')) example = torch.rand(1, 2, SHAPE, SHAPE) model.eval() with torch.no_grad(): traced_script_module = torch.jit.trace(model, example) traced_script_module.save(jit_model_name) mcts = cmcts.mcts(cpuct=CPUCT) mcts.set_alpha_default() mcts.set_threads(THREADS) mcts.set_params(jit_model_name) while True: print("DBG:Play: waiting for connection") server.connect() while True: cmd, move = server.get_cmd() if cmd == cmds.OP_MOVE: print("Opponents move") sys.stdout.flush() mcts.make_movexy(x=move[0], y=move[1]) elif cmd == cmds.MAKE_MOVE: print("My move sims {}".format(SIMS)) sys.stdout.flush() mcts.simulate(SIMS) print("get") pi = mcts.get_prob() mcts.print_node([]) move = np.argmax(pi) mcts.make_move(move) print("made move") server.make_move((move % SHAPE, move // SHAPE)) elif cmd == cmds.LOAD_MOVE: print("Loading move") sys.stdout.flush() raise NotImplementedError #game.set_player() #game.make_move(move) #game.set_player(1) elif cmd == cmds.INITIALIZE: print("Initializing") sys.stdout.flush() print(move) #assert move == SHAPE mcts.clear() elif cmd == cmds.END: print("End") sys.stdout.flush() break else: print('Error: unknow command: ' + cmd) sys.stdout.flush() raise NotImplementedError return