class LSTM(NoiseAwareModel): """Long Short-Term Memory.""" def __init__(self): self.lstm = None self.w = None def train(self, training_candidates, training_marginals, **hyperparams): self.lstm = LSTMModel(training_candidates, training_marginals) self.lstm.train(**hyperparams) def marginals(self, test_candidates): return self.lstm.test(test_candidates) def save(self, session, param_set_name): raise NotImplementedError()
def train(self, training_candidates, training_marginals, **hyperparams): self.lstm = LSTMModel(training_candidates, training_marginals) self.lstm.train(**hyperparams)
from connection import get_stock_data, get_stocks from lstm import LSTMModel import numpy as np import pandas as pd import datetime from tqdm import tqdm stocks = get_stocks() ids = stocks['id'] newest_date = datetime.date(day=1, month=1, year=2020) predictor = LSTMModel() for stock_id in tqdm(ids): stock_data = get_stock_data([stock_id]) stock_data = stock_data[stock_data['date'] < newest_date] predictor.add_data(stock_data, is_train=True) predictor.finalise_input() predictor.train_model() # stock_data = stock_data.set_index('date') # stock_data.index = pd.to_datetime(stock_data.index) # stock_data = stock_data.sort_index().resample('D').mean() # Split data in case we have more than 4 missing days # print(stock_data.id.isnull().astype(int).groupby(stock_data.id.notnull().astype(int).cumsum()).sum())
inputs = [eval_inputs] if args.const_folding: outputs = [ tf.identity(tf.identity(logits, name="logits"), name="logits_identity") ] else: outputs = [tf.identity(logits, name="logits")] elif args.model_name == 'lstm': print('>> Converting graph lstm') batch_size = 1 hidden_size = 256 num_layer = 10 num_step = 100 #sequence length model = LSTMModel(num_layer, hidden_size) eval_inputs = tf.placeholder(tf.float32, [num_step, batch_size, hidden_size], 'eval_input') lstm_output, lstm_state = model.run(eval_inputs, batch_size, num_step) inputs = [eval_inputs] if args.const_folding: outputs = [ tf.identity(tf.identity(lstm_output, name="logits"), name="logits_identity") ] else: outputs = [tf.identity(lstm_output, name="logits")] elif args.model_name == 'nasnet_cifar': print('>> Converting graph nasnet_cifar')
glove=args.glove, emb_size=args.emb_size) # Initialize model assert args.model in ["CNN", "LSTM", "BILSTM"], "Only support CNN, LSTM or BILSTM." if args.model == "CNN": model = CNNModel(vocab_size, args.emb_size, args.max_seq_length, weights=vocab_weights, fix_emb_weight=args.fix_emb) elif args.model == "LSTM": model = LSTMModel(vocab_size, args.emb_size, args.max_seq_length, weights=vocab_weights, fix_emb_weight=args.fix_emb) else: model = BILSTMModel(vocab_size, args.emb_size, args.max_seq_length, weights=vocab_weights, fix_emb_weight=args.fix_emb) model = model.to(device) # Train print("Training %s ..." % args.model) params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
encoderInput = SequenceSubstring(mnist_trainData, seqSubstringLen=5) decoderTarget = SequenceSubstring(mnist_trainData, seqSubstringOffset=5) decoderStartSymbol = np.zeros((4, )) decoderInput = SequenceToSequenceData(decoderTarget, SequenceToSequenceDataType.InputData, decoderStartSymbol) trainData_inputsOutputs = SequenceCombiner([encoderInput, decoderInput], [decoderTarget]) mnist_trainData_subsets = [0.85, 0.15] mnist_trainSubset = SequenceSubset(trainData_inputsOutputs, mnist_trainData_subsets, 0) mnist_validationSubset = SequenceSubset(trainData_inputsOutputs, mnist_trainData_subsets, 1) lstmCells = 16 lstmLayers = 1 modelCheckPointPrefix = 'lstmModel_{}units_{}layer'.format( lstmCells, lstmLayers) model = LSTMModel(lstmCells, lstmLayers, (4, )) trainingModel = model.buildTrainingModel() trainingModel.compile(optimizer='Adam', loss='mse') trainingModel.fit_generator(mnist_trainSubset, epochs=1000, validation_data=mnist_validationSubset, callbacks=[ ModelCheckpoint(modelCheckPointPrefix, period=1), CosineAnnealingSchedule(1e-5, 1e-2, 2) ])
import requests import pandas as pd from consts import Consts import numpy as np from logistic import LogisticModel from lstm import LSTMModel from data import DataAnalyzer ''' Main Code to Train and Run Models ''' da = DataAnalyzer() da.reportData() totalUSCases = np.array( [da.getTotal(da.data, t=i) for i in range(1, len(da.data.columns))]) modelType = input("logistic or lstm ") if modelType == "logistic": model = LogisticModel(totalUSCases) model.trainLogistic() model.graph() elif modelType == "lstm": daysIntoFuture = int(input("Input Number of Days Into the Future ")) sampleSize = int(input("Input Sample Size ")) epochs = int(input("Input Number of Epochs ")) units = int(input("Input Number of LSTM Units ")) LSTM = LSTMModel(totalUSCases, daysIntoFuture, sampleSize, units, epochs) LSTM.model() else: print("Invalid")
def main(_): if FLAGS.seed != -1: np.random.seed(FLAGS.seed) tf.set_random_seed(FLAGS.seed) print("Creating model...") model = LSTMModel(FLAGS.input_size, FLAGS.output_size, FLAGS.num_layers, FLAGS.num_units, FLAGS.direction, FLAGS.learning_rate, FLAGS.dropout, FLAGS.seed, is_training=FLAGS.action == 0, model=FLAGS.model) if FLAGS.action == 0: # TRAINING assert FLAGS.model != 1 data_storage = data_processing.prepare_all_data(FLAGS.time_len) model.train(data_storage, FLAGS.batch_size, FLAGS.num_epochs) # inputs, labels, inputs_valid, labels_valid = data_processing.prepare_data(FLAGS.time_len) # model.train(inputs, inputs_valid, labels, labels_valid, # FLAGS.batch_size, FLAGS.num_epochs) elif FLAGS.action == 1: # EVALUATING assert FLAGS.model == 1 or FLAGS.model == 2, \ "main(): evaluated model must be LSTMBlockCell or LSTMCell" set_idx, aug_idx = 7, 4 inputs, labels = data_processing.prepare_indexed_data( None, set_idx, aug_idx) model.predict(inputs, labels) # pkl_index = 7 # world_data, mocap_data = data_processing.load_data( # open("processed_data/data-" + str(pkl_index) + ".pkl", "rb")) # inputs = data_processing.sequence_split_data(world_data, world_data.shape[0]) # labels = data_processing.sequence_split_data(mocap_data, mocap_data.shape[0]) # #inputs, labels = data_processing.augment_data(inputs, labels) # model.predict(inputs, labels) elif FLAGS.action == 2: # EXPORTING assert FLAGS.model == 1 or FLAGS.model == 2, \ "main(): evaluated model must be LSTMBlockCell or LSTMCell" if FLAGS.model == 1: model.export_weights() elif FLAGS.model == 2: model.export() elif FLAGS.action == 3: # PREDICTING assert FLAGS.model == 1 or FLAGS.model == 2, \ "main(): predicting model must be LSTMBlockCell or LSTMCell" set_idx, aug_idx = 0, 0 inputs, labels = data_processing.prepare_indexed_data( None, set_idx, aug_idx) loss, logits = model.predict(inputs, labels) predicts = data_processing.convert_logits_to_predicts(logits) org_labels = data_processing.convert_logits_to_predicts(labels) print(predicts[:, :3], org_labels[:, :3]) mae = np.mean(np.abs(predicts - org_labels), axis=0) line = "" for i in range(22): line += "{0:.5f}".format(np.mean(mae[3 * i:3 * i + 3])) + " " print(line) print(np.mean(mae[3:]))