def mini_topsim(): """ Reads the Simulation parameters, starts the sim, plots and writes to file the first sys.argv[1] is the simulation time the second sys.argv[2] is the timestep if no sys arguments are passed the simulation starts with tend=10 and dt=1 creates a Surface Object and starts the simulation. the correct timestep is calculated with the timestep function from the advance module. Writes all calculated datapoints to a file with the filenname: basic_<tend>_<dt>.srf plots the simulation fpr t = 0 and t = tend """ print('Running miniTopSim ...') if len(sys.argv) > 1: config_filename = sys.argv[1] else: config_filename = './config1.cfg' config_file = os.path.join(os.path.dirname(__file__), config_filename) if not config_file.endswith('.cfg'): print('Error: Incorrect config.') sys.exit() filename = config_file[:-4] + '.srf' if os.path.exists(filename): os.remove(filename) par.load_parameters(config_file) tend = par.TOTAL_TIME dt = par.TIME_STEP surface = Surface() time = 0 while time < tend: surface.write(time, filename) dtime = timestep(dt, time, tend) advance(surface, dtime) time += dtime surface.write(time, filename) if par.PLOT_SURFACE: plot.plot(filename)
def mini_topsim(): """ Reads the Simulation parameters, starts the sim, plots and writes to file the first sys.argv[1] is the config file name. if no sys argument is passed the programm will stop. Writes all calculated datapoints to a file with the filenname: <config_file_name>.srf """ print('Running miniTopSim ...') if len(sys.argv) > 1: config_filename = sys.argv[1] else: print("Error: No config passed.") sys.exit() config_file = os.path.join(os.path.dirname(__file__), config_filename) if not config_file.endswith('.cfg'): print('Error: Incorrect config.') sys.exit() filename = os.path.splitext(config_file)[0] + '.srf' if os.path.exists(filename): os.remove(filename) par.load_parameters(config_file) tend = par.TOTAL_TIME dt = par.TIME_STEP surface = Surface() time = 0 while time < tend: surface.write(time, filename) dtime = timestep(dt, time, tend) advance(surface, dtime) time += dtime surface.write(time, filename) if par.PLOT_SURFACE: plot.plot(filename)
def main(_): config=parameters.load_parameters() eval_config= copy.deepcopy(config) eval_config.batch_size=1 config_json = json.dumps(vars(config), indent=4, sort_keys=True) #print ("config",config_json) Train,Dev,Test,vocab = reader.file2seqid(config) pretrain_embedding = generate_embeddings(config.glove_path,vocab, config.glove_dir) with tf.Graph().as_default(): #initializer = tf.contrib.layers.xavier_initializer(uniform=True,seed=None,dtype=tf.float32) initializer = tf.random_uniform_initializer(-config.init_scale,config.init_scale) with tf.name_scope("Train"): with tf.variable_scope("Model", reuse=None, initializer=initializer): m = MyModel(is_training=True, config=config,pretrain_embedding=pretrain_embedding) with tf.name_scope("Valid"): with tf.variable_scope("Model", reuse=True, initializer=initializer): mvalid = MyModel(is_training=False,config=eval_config,pretrain_embedding=pretrain_embedding) with tf.name_scope("Test"): with tf.variable_scope("Model", reuse=True, initializer=initializer): mtest = MyModel(is_training=False, config=eval_config,pretrain_embedding=pretrain_embedding) sv = tf.train.Supervisor() #logdir用来保存checkpoint和summary with sv.managed_session() as session: print ("model params",np.sum([np.product([xi.value for xi in x.get_shape()]) for x in tf.trainable_variables()])) model_existed=False if config.restore_model !=None: print ("restore model from: %s "%(config.restore_model)) sv.saver.restore(session, config.restore_model) model_existed=True else: #ckpt = tf.train.get_checkpoint_state(config.save_path) ckpt_file = os.path.join(config.log_path, config.save_path) ckpt = tf.train.get_checkpoint_state(ckpt_file) if ckpt and ckpt.model_checkpoint_path: print ("restore model from: %s "%(ckpt.model_checkpoint_path)) sv.saver.restore(session, ckpt.model_checkpoint_path) init_step = int(ckpt.model_checkpoint_path.rsplit('-',1)[1]) model_existed=True #dev_acc,dev_loss,_,_,dev_pred,dev_label,dev_pred_total,dev_true_total= run_epoch(session,data=Dev,model=mvalid,config=eval_config) #print("Epoch: %d dev_acc: %.3f dev_loss %.3f" % (i + 1, dev_acc,dev_loss)) if model_existed==True: test_acc,test_loss,_,_,test_pred_label,test_true_label = run_epoch(session, data=Test,model=mtest,config=eval_config) print("\n\n-----------------------testing!!!-----------------------" ) print("test_acc: %.3f test_loss %.3f" % (test_acc,test_loss)) print("\nthe confuse_matrix of test:\n") print(confuse_matrix(true_label_total=test_true_label,pred_label_total=test_pred_label,config=config)) #label_input(true_label=test_true_label, # pred_label=test_pred_label, # input_file=config.test_file, # output_file=FLAGS.label_out_file) else: print ("pretrained model does not exist")
def read_parameters(alternative=False): global attribute_skill_dict global armor_names global attribute_names global character_names global notes_names global parameter_names param_dict = load_parameters(alternative=alternative) attribute_skill_dict = param_dict["skill"] armor_names = param_dict["armor"] attribute_names = param_dict["attrib"] character_names = param_dict["character"] notes_names = param_dict["notes"] parameter_names = param_dict["param"]
import numpy as np import re import random import json import collections import parameters as params import pickle FIXED_PARAMETERS = params.load_parameters() LABEL_MAP = {"entailment": 0, "neutral": 1, "contradiction": 2, "hidden": 0} PADDING = "<PAD>" UNKNOWN = "<unk>" def load_nli_data(path, snli=False, lower=True): """ Load MultiNLI or SNLI data. If the "snli" parameter is set to True, a genre label of snli will be assigned to the data. """ data = [] with open(path) as f: for line in f: loaded_example = json.loads(line) if lower: loaded_example['sentence1_binary_parse'] = loaded_example[ 'sentence1_binary_parse'].lower() loaded_example['sentence2_binary_parse'] = loaded_example[ 'sentence2_binary_parse'].lower() if loaded_example["gold_label"] not in LABEL_MAP:
def main(_): config=parameters.load_parameters() eval_config= copy.deepcopy(config) eval_config.batch_size=1 config_json = json.dumps(vars(config), indent=4, sort_keys=True) if not os.path.exists(config.log_path): os.makedirs(config.log_path) if config.test: logpath = "{}/{}".format(config.log_path, config.save_path) + "_test.log" else: logpath = "{}/{}".format(config.log_path, config.save_path) + ".log" logger = Logger(logpath) ckpt_file = os.path.join(config.log_path, config.save_path) + "/model" logger.Log ('config: %s'%(config_json,)) Train,Dev,Test,vocab = reader.file2seqid(config) pretrain_embedding = generate_embeddings(config.glove_path,vocab, config.glove_dir) tf.set_random_seed(config.seed) with tf.Graph().as_default(): #initializer = tf.contrib.layers.xavier_initializer(uniform=True,seed=None,dtype=tf.float32) initializer = tf.random_uniform_initializer(-config.init_scale,config.init_scale) with tf.name_scope("Train"): with tf.variable_scope("Model", reuse=None, initializer=initializer): m = MyModel(is_training=True, config=config,pretrain_embedding=pretrain_embedding) with tf.name_scope("Valid"): with tf.variable_scope("Model", reuse=True, initializer=initializer): mvalid = MyModel(is_training=False,config=eval_config,pretrain_embedding=pretrain_embedding) with tf.name_scope("Test"): with tf.variable_scope("Model", reuse=True, initializer=initializer): mtest = MyModel(is_training=False, config=eval_config,pretrain_embedding=pretrain_embedding) #sv = tf.train.Supervisor(logdir=config.save_path) sv = tf.train.Supervisor() with sv.managed_session() as session: logger.Log("\n\nmodel params:%s"%(np.sum([np.product([xi.value for xi in x.get_shape()]) for x in tf.trainable_variables()]))) t0=time.time() best_accuracy = config.best_accuracy best_val_epoch = config.best_val_epoch last_change_epoch = 0 best_test_acc=0 best_test_epoch=0 #global train_acc for i in range(config.MAXITER): start_time=time.time() train_acc,train_loss,train_global_step,learning_rate,train_pred_total,train_true_total= run_epoch(session,data=Train, model=m,config=config, eval_op=m.optim, verbose=True) logger.Log("Epoch: %d train_acc: %.3f train_loss %.3f train_global_step:%s" % (i,train_acc,train_loss,train_global_step)) dev_acc,dev_loss,_,_,dev_pred_total,dev_true_total= run_epoch(session,data=Dev,model=mvalid,config=eval_config) logger.Log("Epoch: %d dev_acc: %.3f dev_loss %.3f" % (i, dev_acc,dev_loss)) sys.stdout.flush() # if <= then update if best_accuracy <= dev_acc: best_accuracy = dev_acc best_val_epoch = i if config.save_path: logger.Log("Saving model %d to %s." % (i,ckpt_file)) sv.saver.save(session,ckpt_file, global_step=train_global_step) if (i - best_val_epoch > config.update_learning)and(i-last_change_epoch>config.change_epoch): if learning_rate>config.min_lr: lr_decay = config.lr_decay ** max(i - config.max_epoch, 0.0) new_learning_rate = config.learning_rate * lr_decay last_change_epoch= i logger.Log("learning_rate-->change!Dang!Dang!Dang!-->%.10f"%(new_learning_rate)) m.assign_lr(session,new_learning_rate) logger.Log (time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())) end_time=time.time() logger.Log("-------- all_training time: %s one_epoch time: %s\n " % ((end_time-t0)//60, (end_time-start_time)//60)) if i - best_val_epoch > config.early_stopping: logger.Log ("best_val_epoch:%d best_val_accuracy:%.3f"%(best_val_epoch,best_accuracy)) logging.info("Normal Early stop") logger.Log (time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())) break elif i == config.MAXITER-1: logger.Log ("best_val_epoch:%d best_val_accuracy:%.3f"%(best_val_epoch,best_accuracy)) logging.info("Finishe Training") logger.Log("\n\n-----------------------testing!!!-----------------------" ) #### evaluate on the test set #1. restore the best parameters #2. test on the test set and logger.Log confusion matrix #ckpt = tf.train.get_checkpoint_state(config.save_path) ckpt = tf.train.get_checkpoint_state(ckpt_file) if ckpt and ckpt.model_checkpoint_path: #init_step = int(ckpt.model_checkpoint_path.rsplit('-',1)[1]) logger.Log ("restore best model:%s for testing:"%(ckpt.model_checkpoint_path)) sv.saver.restore(session, ckpt.model_checkpoint_path) test_acc,test_loss,_,_,test_pred_total,test_true_total = run_epoch(session, data=Test,model=mtest,config=eval_config) logger.Log ("best_test_accuracy:%.3f test_loss %.3f "%(test_acc,test_loss)) logger.Log("\nthe confuse_matrix of test:\n") logger.Log(confuse_matrix(true_label_total=test_true_total,pred_label_total=test_pred_total,config=config)) logger.Log (time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
def mini_topsim(config_file=None): """ Loads parameters from config_file, starts the sim, plots and writes to file :param config_file: config_file with simulation parameters Loads parameters from config_file. If no config_file is passed passed, None is returned. Creates a Surface Object and starts the simulation. The correct timestep is calculated with the timestep function from the advance module. If a *.srf_save file with the same filename exists, the plot function with both surfaces is called. """ print('Running miniTopSim ...') if config_file is None: if len(sys.argv) > 1: config_filename = sys.argv[1] else: sys.exit('No Config file passed') #config_filename = 'cosine.cfg' config_file = config_filename if not config_file.endswith('.cfg'): print('Error: Incorrect config.') sys.exit() filename = os.path.splitext(config_file)[0] + '.srf' if os.path.exists(filename): os.remove(filename) par.load_parameters(config_file) dir_path = os.path.dirname(os.path.realpath(config_file)) par.INITIAL_SURFACE_FILE = os.path.join(dir_path, par.INITIAL_SURFACE_FILE) tend = par.TOTAL_TIME dt = par.TIME_STEP surface = Surface() sputter.init_sputtering() time = 0 start_simulation_time = currenttime() while time < tend: surface.write(time, filename) dtime = timestep(dt, time, tend) advance(surface, dtime) surface.eliminate_overhangs() time += dtime stop_simulation_time = currenttime() simulation_time = stop_simulation_time - start_simulation_time print('The Simulation took: {}s'.format(float(simulation_time))) surface.write(time, filename) filename_save = filename + '_save' if par.PLOT_SURFACE: if os.path.exists(filename_save): print('*.srf_save file exists... plotting both!') plot.plot(filename, filename_save) else: plot.plot(filename)
#!/usr/bin/python from pprint import pprint import yaml import parameters import update_rules print yaml.dump(update_rules.RProp()) p = parameters.load_parameters('mnist-vanilla.yaml') print p.dataset
time = np.fromstring(data[3*n+1]) omega = np.fromstring(data[3*n+2]) u_set.add(param[0]) V_set.add(param[1]) Cr_set.add(param[2]) k_set.add(param[3]) Ce_set.add(param[4]) lamb_set.add(param[5]) time_omega = np.transpose(np.vstack((time, omega))) tab[len(u_set)-1, len(V_set)-1, len(Cr_set)-1, len(k_set)-1, len(Ce_set)-1, len(lamb_set)-1] = time_omega return tab, u_array, V_array, Cr_array, k_array, Ce_array, lamb_array if __name__ == '__main__': C_e_command = 20 _J, _C_r, _R, _k, _V, _C_e, _lamb = parameters.load_parameters() om_t = simulation.om_theo(_C_r, _R, _k, 9, C_e_command, _lamb) # ============| Affichage des données |================= _N_samples = 1000 _V_array = np.array([9] * _N_samples) t, v, o, c, p = simulation.euler(simulation.f, 0, 20, _N_samples, 0, _V_array, C_e=C_e_command) k = ind_reg_perm(o, om_t) print(f"Indice du régime permanent : {k}") print(f"Temps auquel regime permanent atteint : {t[k]:.3f}") print(f"Comparaison des valeurs : {om_t:.4f} vs {o[k]:.4f}") save_o, save_t = val_sauv_om_t(o, t, k, 100) print("Nombre de valeurs retenues : ", len(save_o))
import matplotlib.pyplot as plt config_filename="test_overhangs.cfg" config_file = os.path.join(os.path.dirname(__file__), config_filename) if not config_file.endswith('.cfg'): print('Error: Incorrect config.') sys.exit() filename = os.path.splitext(config_file)[0] + '.srf' if os.path.exists(filename): os.remove(filename) par.load_parameters(config_file) #Example Surface surface = Surface() surface.xvals=[0.,1.,2.,1.,1.5,3.,4.,5.,4.,5.,6.,7.,8.,7.,7.5,8.,9.] surface.yvals=[10.,10.,10.,15.,17.,18.,18.,18.,12.,13.,13.,12.,11.,10.,9.,8.,8.] plt.title('Eliminate Overhangs Test') plt.ylabel('Surface Y values') plt.xlabel('Surface X values') plt.plot(surface.xvals, surface.yvals, 'b-', label='With Overhangs') surface.eliminate_overhangs() plt.plot(surface.xvals, surface.yvals, 'r-', label='Without Overhangs') plt.legend()
from PyQt5.QtWidgets import (QPushButton, QWidget, QAction, QSpacerItem, QSizePolicy, QVBoxLayout, QHBoxLayout, QLabel, QScrollArea, QLineEdit, QCheckBox, QMenu, QComboBox, QTextEdit, QTableWidget, QHeaderView, QToolButton) from PyQt5.QtCore import pyqtSignal from PyQt5.QtCore import Qt from PyQt5.QtGui import QValidator, QColor, QDoubleValidator # from parameters import translate, translate from parameters import load_parameters, translate, is_types, is_type from item_classes import BaseObject param_dict = load_parameters() armor_names = param_dict["armor"] line_edit_style = "QLineEdit { background: rgba(255, 255, 255, 100); border-width: 0px;\ alternate-background-color: rgba(200,200,200,50); font: bold 10px; margin: 0px;}" class ScrollContainer(QWidget): item_created = pyqtSignal(str, object) item_equipped = pyqtSignal(str, object, bool) item_removed = pyqtSignal(str, object) item_edited = pyqtSignal(str, object) def __init__(self, name, button_text, content_widget, popup=None, label=None, **kwargs): QWidget.__init__(self) # self.parent = parent self.name = name self.kwargs = kwargs self.layout = QVBoxLayout() self.label = QLabel(translate(name))
import parameters from six.moves import xrange import numpy as np _PAD="_PAD" _UNK= "_UNK" _GO= "_GO" _EOS= "_EOS" _START_VOCAB=[_PAD,_UNK,_GO,_EOS] LABEL_MAP={"neutral":0,"entailment":1,"entails":1,"contradiction":2,"hidden":-1,"NEUTRAL":0,"ENTAILMENT":1,"CONTRADICTION":2} PAD_ID=0 UNK_ID=1 GO_ID =2 EOS_ID =3 #config=Config.load_parameters()#return config form a function of Config.py config=parameters.load_parameters()#return config form a function of Config.py def filter_length(seq,maxlen): if len(seq)>maxlen: new_seq=seq[:maxlen] else: new_seq=seq return new_seq def load_data(train,vocab,labels=LABEL_MAP): X,Y,Z=[],[],[] #f_l=open("seq.txt","w+") for p,h,l in train: p=map_to_idx(tokenize(p),vocab)+ [EOS_ID] h=[GO_ID]+map_to_idx(tokenize(h),vocab)+ [EOS_ID] p=filter_length(p,config.xmaxlen) h=filter_length(h,config.ymaxlen)
import re import random import json import gzip import pickle import collections import numpy as np from tqdm import tqdm import nltk from nltk.corpus import wordnet as wn import os import pickle import multiprocessing import parameters config = parameters.load_parameters() def generate_embeddings(pretrain_embedding_path, word_indices, embedding_file_name): embedding_dir = config.embedding_dir if not os.path.exists(config.embedding_dir): os.makedirs(embedding_dir) #embedding_path = os.path.join(embedding_dir,embedding_file_name) embedding_path = embedding_file_name #logger.Log("embedding path:%s %r"%(embedding_path, os.path.exists(embedding_path))) print("embedding path:%s %r" % (embedding_path, os.path.exists(embedding_path))) if os.path.exists(embedding_path) and config.rebuiltGloveEmb == False:
"""Profiling to get insight in performance issues.""" import cProfile, pstats, io pr = cProfile.Profile() pr.enable() generate_commands() pr.disable() s = io.StringIO() ps = pstats.Stats(pr, stream=s).sort_stats('cumulative') ps.print_stats() logging.info(s.getvalue()) s.close() # Initialize the game. game = Game() load_parameters(game) logging.info(param) # Define some globals for convenience. me = game.me game_map = game.game_map MapData(game, None) while(time.time() - bot_start < 9.7 and DistanceCalculator.needs_precompute()): DistanceCalculator.precompute() # Play the game. game.ready("TeamSchildpad") while True: game.update_frame() start = time.time()
def mini_topsim_timing(): """ Reads the Simulation parameters, starts the sim, plots and writes to file the first sys.argv[1] is the config file name. if no sys argument is passed the programm will stop. Writes all calculated datapoints to a file with the filenname: <config_file_name>.srf """ print('Running miniTopSim ...') if len(sys.argv) > 1: config_filename = sys.argv[1] else: print("Error: No config passed.") sys.exit() config_file = os.path.join(os.path.dirname(__file__), config_filename) if not config_file.endswith('.cfg'): print('Error: Incorrect config.') sys.exit() filename = os.path.splitext(config_file)[0] + '.srf' if os.path.exists(filename): os.remove(filename) par.load_parameters(config_file) tend = par.TOTAL_TIME dt = par.TIME_STEP par.DELTA_X = 10 simulation_time_array = np.empty((2, 0)) while par.DELTA_X > 0.2: # print(par.DELTA_X) surface = Surface() time = 0 start_simulation_time = currenttime() while time < tend: surface.write(time, filename) dtime = timestep(dt, time, tend) advance(surface, dtime) time += dtime stop_simulation_time = currenttime() simulation_time = stop_simulation_time - start_simulation_time simulation_time_array = np.append(simulation_time_array, np.array( (int(100 / par.DELTA_X), simulation_time)).reshape(2, 1), axis=1) # print('The Simulation took: {}s'.format(float(simulation_time))) # print(np.array((int(100/par.DELTA_X)))) # print(par.DELTA_X) surface.write(time, filename) par.DELTA_X = par.DELTA_X - 0.6 # print(par.DELTA_X) plt.title('Simulationtime in dependence of the number of points') plt.plot(simulation_time_array[0], simulation_time_array[1], 'b+-') plt.xscale('log') plt.yscale('log') plt.xlabel('Number of points') plt.ylabel('Time in Seconds') plt.grid(which='both') plt.show() if par.PLOT_SURFACE: plot.plot(filename)