def __init__(self): """ Initializes the game controller so it is ready to start a new game. """ parser = ArgumentParser( description='A simple console-based rogue-like game.') parser.add_argument('map_path', type=str, nargs='?', help='path to map file to load') parser.add_argument('--new_game', nargs='?', dest='new_game_demanded', const=True, default=False) args = parser.parse_args() no_save_file = not os.path.isfile(SAVE_FILE_NAME) if args.new_game_demanded or no_save_file: if args.map_path is not None: game_map = FileWorldMapSource(args.map_path).get() else: game_map = RandomV1WorldMapSource( Controller._DEFAULT_MAP_HEIGHT, Controller._DEFAULT_MAP_WIDTH).get() mobs_count = Controller._MOB_COUNT positions = game_map.get_random_empty_positions(mobs_count + 1) player = src.fighter.Player(positions[0], [ WeaponBuilder().with_name('SABER').with_attack(2).with_defence( 2).with_confusion_prob(0.2), WeaponBuilder().with_name('SPEAR').with_attack(4).with_defence( 1).with_confusion_prob(0.1), WeaponBuilder().with_name('SWORD').with_attack(1).with_defence( 3).with_confusion_prob(0.7) ]) mobs = [ src.fighter.Mob( positions[i], random.choice([ src.strategies.AggressiveStrategy(), src.strategies.PassiveStrategy(), src.strategies.CowardlyStrategy() ])) for i in range(1, mobs_count + 1) ] self.model = model.Model(game_map, player, mobs) else: with open(SAVE_FILE_NAME, 'r') as file: self.model = model.Model(None, None, None) self.model.set_snapshot(file.read()) self.program_is_running = True self.view = None self.player_died = False self.fighting_system = CoolFightingSystem()
def test_train_one_epoch_split_3(self): num_cells = 4 train_dataset, test_dataset = model_lib.make_datasets( 'src/testutils/corpus/split-3/0-*.png', num_cells) model = model_lib.Model(train_dataset, test_dataset, epochs=1, num_cells=num_cells) model.fit() self.assertEqual(model.generator.input_shape, (None, 256, 256, 3)) self.assertEqual(model.generator.output_shape, (None, 256, 256, 1)) self.assertFalse(model.generator.run_eagerly) with tempfile.NamedTemporaryFile(mode='w+', suffix=".png") as tmp_file: # We can't assert anything about the generated image, but we just # want to see that imageutils.predict(generator, ...) doesn't fail. imageutils.predict(model.generator, _PATH_TO_FONT, [ '市', '口', '來', ], tmp_file.name) # We want to see that model_lib.generate_images(generator, ...) doesn't # fail. for items in test_dataset.take(1): inputs = items[:-1] target = items[-1] model_lib.generate_images(model.generator, inputs, target)
def setUp(self): rating_file = "./fakedataset/dw_rating.dat" id_map_file = "./fakedataset/dw_id_map.mat" active_user_file = "./fakedataset/dw_active_users_all.mat" dst_filename = "./fakedataset/dw_user_item_matrix.mat" self.mat = dw.get_orignal_data(rating_file, id_map_file, active_user_file, dst_filename) self.model = model.Model(self.mat)
def __init__(self, grammar, checkpointed=False, threshold=0): self.checkpointed = checkpointed self.language = grammar.split("/")[-1][8:-4] self.generator = generator.Generator(self.language) self.parser = subparser.Parser(self.language) if checkpointed: self.model = model_checkpointed.ModelCheckpointed( self.language, threshold) else: self.model = model.Model(self.language)
"""Start function for the entire model. This module simply imports all the functions needed to apply the model on the data and calls them one by one. """ import pickle from src import config from src import model if __name__ == '__main__': influenza_estimator = model.Model() influenza_estimator.train()
def main(): # PARAMETERS # training params num_training_epochs = 1000 # 3000 stopping_criterion = 0.0 # 0.0 train_batch_size = 1 # 1 # optimization params learning_rate = 0.1 # 0.01 # model params representation_nonlinearity = "sigmoid" # "sigmoid" hidden_nonlinearity = "sigmoid" # "sigmoid" # initialization params weight_initialization_range = [-0.1, 0.1] # [-0.1, 0.1] output_layer_bias_val = -2. # -2. freeze_output_layer_biases = True # True # set up result dirs t_m.make_dir("logdirs") save_dir = t_m.get_logdir() print('Results will be saved in: {}'.format(save_dir)) # create dataset data_fname = "data/data_01/data.csv" new_items = [[], [], []] representation_units_to_add = [0, 7] for ix, items_to_consider in enumerate( [["plant", "tree", "flower", "oak", "pine", "daisy", "rose"], ["animal", "birds", "fish", "robin", "canary", "sunfish", "salmon"]]): num_training_epochs = [2000, 4000][ix] dataset = d_m.Dataset(data_fname=data_fname, items_to_consider=items_to_consider) # create model # some model and train params are locked to dataset params item_input_size = len(dataset.item_names_to_inds) relation_input_size = len(dataset.relation_names_to_inds) representation_size = 7 + sum(representation_units_to_add[:ix]) hidden_size = 15 # 15 output_size = len(dataset.attribute_names_to_inds) model = m_m.Model( item_input_size=item_input_size, relation_input_size=relation_input_size, representation_size=representation_size, hidden_size=hidden_size, output_size=output_size, representation_nonlinearity=representation_nonlinearity, hidden_nonlinearity=hidden_nonlinearity, wrange=weight_initialization_range, output_layer_bias_val=output_layer_bias_val, freeze_output_layer_biases=freeze_output_layer_biases) # create trainer trainer = t_m.Trainer( dataset, model, name="{}".format(0), train_batch_size=train_batch_size, num_training_epochs=num_training_epochs, stopping_criterion=stopping_criterion, learning_rate=learning_rate, save_dir=save_dir, test_freq=50, print_freq=100, show_plot=True, new_items=new_items[ix], representation_units_to_add=representation_units_to_add[ix]) trainer.train()
print("load dataset") use_supplement = tf.placeholder_with_default(False, []) few_real_images, few_real_labels = MNIST.MNIST(batch_size) supplementary_real_images, supplementary_real_labels = MNIST.MNIST( large_batch_size - batch_size) many_real_images = tf.concat([few_real_images, supplementary_real_images], axis=0) many_real_labels = tf.concat([few_real_labels, supplementary_real_labels], axis=0) minibatch_real_images, minibatch_real_labels = tf.cond( use_supplement, lambda: (many_real_images, many_real_labels), lambda: (few_real_images, few_real_labels)) print("build model") model = Model.Model(num_channel=num_channel, num_class=num_class) minibatch_batch_size = tf.shape(minibatch_real_images)[0] noise_batch_size = tf.placeholder_with_default(minibatch_batch_size, []) default_fake_labels = minibatch_real_labels if conditioned_model and same_labels else None # None means random-labeled or non-conditioned. noise = model._random_noise(noise_batch_size, default_labels=default_fake_labels) real_labels = minibatch_real_labels if conditioned_model else None model.build_network_outputs(noise, minibatch_real_images, fake_labels=default_fake_labels, real_labels=real_labels) model.build_losses() print("build opt") opt = tf.train.AdamOptimizer(learning_rate=2.0e-4) with tf.control_dependencies(
import chess.engine from src import model engine = chess.engine.SimpleEngine.popen_uci('/usr/games/stockfish') board = chess.Board() info = engine.analyse(board, chess.engine.Limit(time=0.100)) print(info) print("score= ", info['score']) print(type(info['score'])) # engine.quit() if __name__ == '__main__': model = model.Model() model.play()
# Parse the arguments parser = argparse.ArgumentParser(description="This script trains my best model") parser.add_argument("-modelName", dest="model_name", required=True, type=str, help="name of the model") parser.add_argument("-data", dest="train_data_path", required=True, type=str, help="location of the training data") parser.add_argument("-target", dest="train_labels_path", required=True, type=str, help="location of the training labels") args = parser.parse_args() # I'm using Windows, so since default of long in Windows is 4 bytes, need to force long as 8 bytes. X_train = torch.tensor(torchfile.load(args.train_data_path, force_8bytes_long=True), dtype=torch.float64).reshape(-1, 108*108).to(device) y_train = torch.tensor(torchfile.load(args.train_labels_path, force_8bytes_long=True), dtype=torch.float64).reshape(-1).long().to(device) # Model definition net = model.Model() net.add_layer(layers.Conv2d((108, 108), 1, 16, kernel_size=18, stride=2)) net.add_layer(layers.ReLU()) net.add_layer(layers.MaxPool2d(2)) net.add_layer(layers.BatchNorm2d(16)) net.add_layer(layers.Conv2d((23, 23), 16, 32, kernel_size=5, stride=2)) net.add_layer(layers.ReLU()) net.add_layer(layers.MaxPool2d(2)) net.add_layer(layers.BatchNorm2d(32)) net.add_layer(layers.Flatten()) net.add_layer(layers.Linear(5 * 5 * 32, 256)) net.add_layer(layers.ReLU()) net.add_layer(layers.BatchNorm1d(256)) net.add_layer(layers.Linear(256, 128)) net.add_layer(layers.ReLU()) net.add_layer(layers.BatchNorm1d(64))
def get_trainer(config): vocab_config = { 'pathes': [config['formulas_train_path'], config['formulas_validation_path']], 'unk_token_threshold': config['unk_token_threshold'], } vocab = utils.Vocab( vocab_config ) # 构建并存储fomula的token表;fomula2tensor与tensor2fomula,return tensor和fomula字符串 vocab_size = len(vocab.token2idx.keys()) # token个数 cnn_model = cnn.CNN(config['cnn_params']).to( config['device']) # 构建cnn模型,提取特征返回x encoder_model = encoder.Encoder(config['cnn_params']['conv6_c'], config['encoder_hidden_size'], config['bidirectional'], config['device']).to(config['device']) # 构建encoder模型,输入x,计算方向 train_loader_config = { 'batch_size': config['batch_size'], 'images_path': config['images_train_path'], 'formulas_path': config['formulas_train_path'], 'sort_by_formulas_len': True, 'shuffle': False, } train_loader = utils.data_loader( vocab, train_loader_config) # 导入数据,并判断是否为end_of_batch embedding_model = embedding.Embedding(vocab_size, config['embedding_size'], vocab.pad_token).to(config['device']) # 对token表中的token进行词嵌入 decoder_model = decoder.DecoderRNN( config['embedding_size'], config['decoder_hidden_size'], config['encoder_hidden_size'] * (2 if config['bidirectional'] else 1), vocab_size, config['device']).to(config['device']) # 构建RNN模型,返回分数 _model = model.Model(cnn_model, encoder_model, embedding_model, decoder_model, config['device']) # 构建整体模型,加入positional embedding,调用generator model trainer_config = { 'device': config['device'], 'checkpoints_dir': config['checkpoints_dir'], 'log_dir': config['log_dir'], 'print_every_batch': config['print_every_batch'], 'clip': config['clip'], 'learning_rate': config['learning_rate'], 'learning_rate_decay': config['learning_rate_decay'], 'learning_rate_decay_step': config['learning_rate_decay_step'], 'learning_rate_min': config['learning_rate_min'], 'teacher_forcing_ratio': config['teacher_forcing_ratio'], 'teacher_forcing_ratio_decay': config['teacher_forcing_ratio_decay'], 'teacher_forcing_ratio_decay_step': config['teacher_forcing_ratio_decay_step'], 'teacher_forcing_ratio_min': config['teacher_forcing_ratio_min'], } _trainer = trainer.Trainer(_model, train_loader, trainer_config) # 模型训练train_one_epoch return _trainer
# collect the raw data : bamber = DataFactory.get_bamber(thklim=thklim) # define the meshes : mesh = Mesh('meshes/greenland_3D_5H.xml') mesh.coordinates()[:, 2] /= 100000.0 # create data objects to use with varglas : dbm = DataInput(None, bamber, mesh=mesh) # get the expressions used by varglas : Surface = dbm.get_spline_expression('h') Bed = dbm.get_spline_expression('b') model = model.Model(out_dir=out_dir) model.set_geometry(Surface, Bed) model.set_mesh(mesh, deform=True) model.set_parameters(pc.IceParameters()) model.initialize_variables() parameters['form_compiler']['quadrature_degree'] = 2 File(in_dir + 'u.xml') >> model.u File(in_dir + 'v.xml') >> model.v File(in_dir + 'w.xml') >> model.w File(in_dir + 'beta2.xml') >> model.beta2 File(in_dir + 'eta.xml') >> model.eta config = {'output_path': out_dir} F = solvers.StokesBalanceSolver(model, config)
def test_get_item_ids(self): i_ids1 = model.Model(self.mat).get_item_ids() i_ids2 = model.Model(self.mat).get_item_ids() self.assertSequenceEqual(i_ids1, i_ids2) self.assertEqual(len(i_ids1), 10)
def test_get_user_ids(self): u_ids = model.Model(self.mat).get_user_ids() self.assertEqual(len(u_ids), 9) u_ids2 = model.Model(self.mat).get_user_ids() self.assertSequenceEqual(u_ids, u_ids2)
def get_trainer(config): vocab_config = { 'pathes': [config['formulas_train_path'], config['formulas_validation_path']], 'unk_token_threshold': config['unk_token_threshold'], } vocab = utils.Vocab(vocab_config) vocab_size = len(vocab.token2idx.keys()) cnn_model = cnn.CNN(config['cnn_params']).to(config['device']) encoder_model = encoder.Encoder(config['cnn_params']['conv6_c'], config['encoder_hidden_size'], config['bidirectional'], config['device']).to(config['device']) train_loader_config = { 'batch_size': config['batch_size'], 'images_path': config['images_train_path'], 'formulas_path': config['formulas_train_path'], 'sort_by_formulas_len': True, 'shuffle': False, } train_loader = utils.data_loader(vocab, train_loader_config) embedding_model = embedding.Embedding(vocab_size, config['embedding_size'], vocab.pad_token).to(config['device']) decoder_model = decoder.AttnDecoder( config['embedding_size'], config['decoder_hidden_size'], config['encoder_hidden_size'] * (2 if config['bidirectional'] else 1), vocab_size, config['device']).to(config['device']) _model = model.Model(cnn_model, encoder_model, embedding_model, decoder_model, config['device']) trainer_config = { 'device': config['device'], 'checkpoints_dir': config['checkpoints_dir'], 'log_dir': config['log_dir'], 'print_every_batch': config['print_every_batch'], 'clip': config['clip'], 'learning_rate': config['learning_rate'], 'learning_rate_decay': config['learning_rate_decay'], 'learning_rate_decay_step': config['learning_rate_decay_step'], 'learning_rate_min': config['learning_rate_min'], 'teacher_forcing_ratio': config['teacher_forcing_ratio'], 'teacher_forcing_ratio_decay': config['teacher_forcing_ratio_decay'], 'teacher_forcing_ratio_decay_step': config['teacher_forcing_ratio_decay_step'], 'teacher_forcing_ratio_min': config['teacher_forcing_ratio_min'], } _trainer = trainer.Trainer(_model, train_loader, trainer_config) return _trainer