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:]))