def main(config): if config.prepare_data: print('==> Data prepration') save_data(config) return data_iterator = load_data_iterator(config) model = build_model(config) trainer = Trainer(config, model, data_iterator) # evaluator = Eval() if config.train: assert config.eval_only == False print('Training Started') loss = [] if config.load_model: trainer.load_checkpoint() path = os.path.join(config.exp_dir, 'loss.pkl') with open(path, 'rb') as f: loss = pickle.load(f) for epoch in range(config.num_epochs): train_losses = trainer.iter() valid_losses = trainer.eval(mode='valid') test_losses = trainer.eval(mode='test') loss.append((train_losses, valid_losses, test_losses)) if config.save_periodic: if epoch % config.save_every == 0: trainer.save_checkpoint(epoch) print(f'Model saved for epoch = {epoch}') if config.dump_loss: path = os.path.join(config.exp_dir, 'loss.pkl') with open(path, 'wb') as f: pickle.dump(loss, f) elif config.eval_only: # evaluator print('Evaluation')
def __init__(self): import keras.backend.tensorflow_backend as K config = tf.ConfigProto() config.gpu_options.allow_growth = True self.session = tf.Session(config=config) K.set_session(self.session) K.manual_variable_initialization(True) self.lp = K.learning_phase() self.model = build_model() self.model._make_predict_function() self.model.summary() self.predict_model = build_model() self.predict_model._make_predict_function() self.graph = self._build_graph(self.model) self.popart = self.popart_ops() self.session.run(tf.global_variables_initializer()) self.default_graph = tf.get_default_graph() self.sync_weight() self.tensorboard_setting() self.default_graph.finalize() self.taskqueue = queue.Queue(maxsize=16)
def predict_from_weights(input_path, weight_path, limit=10): # VGG for the perceptual loss base_model = VGG19(weights="imagenet", include_top=False, input_shape=img_input_shape) perceptual_model = Model(inputs=base_model.input, outputs=[base_model.get_layer("block2_pool").output, base_model.get_layer("block5_pool").output], name="VGG") autoencoder, _ = build_model(perceptual_model) if os.path.isfile(weight_path): print("loading weights from {}".format(weight_path)) autoencoder.load_weights(weight_path) else: raise Exception("weight path does not exist") predict_from_ae(input_path, autoencoder, limit)
def main(args): """ Main function contains the main procedure of training and evaluation. It take args as its argument args: a parser object that contains main configurations of the current experiment """ config = Config(args) set_seed(config) logger = config.get_logger() env = EnvHndler(config) # Clear the cash of CUDA torch.cuda.empty_cache() model = build_model(config) trainer = Trainer(config, env, model) evaluator = Evaluator(trainer) # evaluation if config.eval_only: scores = evaluator.run_all_evals() for k, v in scores.items(): logger.info("%s -> %.6f" % (k, v)) logger.info("__log__:%s" % json.dumps(scores)) exit() # training for epoch in range(config.max_epoch): logger.info("============ Starting epoch %i ... ============" % trainer.epoch) trainer.n_equations = 0 torch.cuda.empty_cache() while trainer.n_equations < trainer.epoch_size: # training steps torch.cuda.empty_cache() trainer.enc_dec_step() trainer.iter() logger.info("============ End of epoch %i ============" % trainer.epoch) # evaluate perplexity scores = evaluator.run_all_evals() # print / JSON log for k, v in scores.items(): logger.info("%s -> %.6f" % (k, v)) logger.info("__log__:%s" % json.dumps(scores)) # end of epoch trainer.save_best_model(scores) trainer.save_periodic() trainer.end_epoch(scores) if epoch % 10 == 0: while True: t = input("Continue training? [y/n]") if t not in ['y', 'n']: print('Invalid input') continue elif t == 'y': break else: exit()
"optimizer": optimizer_params[i], "earlystopping": earlystopping_params[j], "loss_weights": loss_params[k] } for (i, j, k) in [ x for x in itertools.product(optimizer_params, earlystopping_params, loss_params) ]] for idx, exp in enumerate(experiment): print("starting experiment {} with {}".format(idx, exp)) # create sub_experiment file sub_exp_path = exp_path + '/' + str(idx) os.mkdir(sub_exp_path) autoencoder, _ = build_model(perceptual_model) load_model = False if load_model: weight_path = "weights.hdf5" print("loading weights from {}".format(weight_path)) autoencoder.load_weights(weight_path) optimizer = exp["optimizer"][0](**exp["optimizer"][1]) loss_weights = exp["loss_weights"] autoencoder.compile(optimizer=optimizer, loss={ "clipping_layer_1": loss, "rounding_layer_1": entropy, "VGG_block_2": perceptual_2,
training_df, testing_df, training_matrix, testing_matrix = Preprocess.data_separation('2010-01-01', '2017-01-01', '2017-01-01', '2018-01-01', ticker) normalised_data = Preprocess.data_normalisation(ticker) normalised_training_data = Preprocess.normalised_training(training_matrix, normalised_data) normalised_testing_data = Preprocess.normalised_testing(testing_matrix, normalised_data) # Parameters for Time Series Model feature_length = 10 window_length = 20 batch_size = 256 # Create Training samples x_train, y_train = Preprocess.create_samples(normalised_training_data, 20, 10) # Building Time-series model model = build_model([batch_size, window_length, feature_length]) # Back-test output x_test, y_test = Preprocess.create_samples(normalised_testing_data, 20, 10) import datetime # For datetime objects # Import the backtrader platform import backtrader as bt from Trading_Strategy import SentimentStrategy if __name__ == '__main__': cerebro = bt.Cerebro() cerebro.addstrategy(SentimentStrategy)
import pickle import numpy as np from Model import build_model import json import params with open('preprocessing.pkl', 'rb') as f: preprocessing = pickle.load(f) with open('test_data.pkl', 'rb') as f: test_data = pickle.load(f) model = build_model(preprocessing.tokenizer) model.load_weights('Models/model_aws.hdf5') preprocessed_test_data = list() for sample in test_data: if sample[3] < sample[4] < params.CONTEXT_LEN or sample[3] == -1: preprocessed_test_data.append(preprocessing.text_to_seq_sample(sample)) result = {} i = 0 for sample in preprocessed_test_data: id_ = sample[6] pred = model.predict([sample[1].reshape(1, params.QUESTION_LEN), sample[0].reshape(1, params.CONTEXT_LEN)]) p_start = int(np.argmax(pred[0])) p_end = int(np.argmax(pred[1])) is_noans = np.round(pred[2]) result[id_] = preprocessing.target_to_words(sample[0].reshape(-1, ), p_start, p_end, is_noans)
import gym import sys train = False if len(sys.argv) > 1 and sys.argv[1] == "train": train = True env = gym.make("CartPole-v0") #builds and trains model if train: x_data, y_data = get_training_data() model = build_model() history = model.fit(x_data, y_data, epochs=100) model.save('cartpolemodel.h5') # creates graph displaying loss rate plt.plot(history.history['mean_squared_error']) plt.title("Model Loss") plt.xlabel("Epoch") plt.ylabel("Loss") plt.show() #loads model else: model = load_model('cartpolemodel.h5')
class Bunch(object): def __init__(self, adict): self.__dict__.update(adict) if __name__ == "__main__": logging.basicConfig(format='%(asctime)s : %(message)s', level=logging.DEBUG) init_checkpoint = '/u/lupeng/Project/code/Discourse_summ/saved/octal14/transformer_cnndm_01' with open(os.path.join(init_checkpoint, 'config.json'), 'r') as fjson: argparse_dict = json.load(fjson) checkpoint = torch.load(os.path.join(init_checkpoint, 'checkpoint')) args = Bunch(argparse_dict) model = build_model(args, None) model.load_state_dict(checkpoint['model_state_dict']) params_senteval['encoder'] = model logging.info('start evaluating...') se = senteval.engine.SE(params_senteval, batcher) transfer_tasks = [ 'CR', 'MR', 'MPQA', 'SUBJ', 'SST2', 'SST5', 'TREC', 'MRPC', 'SNLI', 'SICKEntailment', 'SICKRelatedness', 'STSBenchmark', 'ImageCaptionRetrieval', 'STS12', 'STS13', 'STS14', 'STS15', 'STS16', 'Length', 'WordContent', 'Depth', 'TopConstituents', 'BigramShift', 'Tense', 'SubjNumber', 'ObjNumber', 'OddManOut', 'CoordinationInversion' ] # result = se.eval(transfer_tasks) # # logging.info(f'result of {task}')