def __init__(self, time_step, split, lr):
self.dataset = Dataset(T=time_step,
split_ratio=split,
binary_file=config.BINARY_DATASET)
self.policy_net_encoder = AttnEncoder(
input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.policy_net_decoder = AttnDecoder(
code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
self.policy_net = DQN(self.policy_net_encoder, self.policy_net_decoder)
self.target_net_encoder = AttnEncoder(
input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.target_net_decoder = AttnDecoder(
code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
self.target_net = DQN(self.target_net_encoder, self.target_net_decoder)
if torch.cuda.is_available():
self.policy_net_encoder = self.policy_net_encoder.cuda()
self.policy_net_decoder = self.policy_net_decoder.cuda()
self.target_net_encoder = self.target_net_encoder.cuda()
self.target_net_decoder = self.target_net_decoder.cuda()
self.policy_net = self.policy_net.cuda()
self.target_net = self.target_net.cuda()
self.memory = ReplayMemory(config.MEMORY_CAPACITY)
self.optimizer = optim.RMSprop(self.policy_net.parameters(), lr=lr)
def __init__(self, driving, target, time_step, split, lr):
self.dataset = Dataset(driving, target, time_step, split)
self.encoder = AttnEncoder(input_size=self.dataset.get_num_features(), hidden_size=config.ENCODER_HIDDEN_SIZE, time_step=time_step)
self.decoder = AttnDecoder(code_hidden_size=config.ENCODER_HIDDEN_SIZE, hidden_size=config.DECODER_HIDDEN_SIZE, time_step=time_step)
if torch.cuda.is_available():
self.encoder = self.encoder.cuda()
self.decoder = self.decoder.cuda()
self.encoder_optim = optim.Adam(self.encoder.parameters(), lr)
self.decoder_optim = optim.Adam(self.decoder.parameters(), lr)
self.loss_func = nn.MSELoss()
self.train_size, self.test_size = self.dataset.get_size()
def __init__(self, time_step, split, lr):
self.dataset = Dataset(T=time_step,
split_ratio=split,
binary_file=config.BINARY_DATASET)
self.encoder = AttnEncoder(input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.decoder = AttnDecoder(code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
self.model = Model(self.encoder, self.decoder)
if torch.cuda.is_available():
self.encoder = self.encoder.cuda()
self.decoder = self.decoder.cuda()
self.model = self.model.cuda()
self.model_optim = optim.Adam(self.model.parameters(), lr)
# self.encoder_optim = optim.Adam(self.encoder.parameters(), lr)
# self.decoder_optim = optim.Adam(self.decoder.parameters(), lr)
self.loss_func = nn.MSELoss()
self.train_size, self.test_size = self.dataset.get_size()
def sample(self, img_dir):
# Image preprocessing
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.033, 0.032, 0.033),
(0.027, 0.027, 0.027))])
# Load vocabulary wrapper
with open(self.vocab_path, 'rb') as f:
vocab = pickle.load(f)
# Build Models
encoder = AttnEncoder(ResidualBlock, [3, 3, 3])
encoder.eval() # evaluation mode (BN uses moving mean/variance)
decoder = AttnDecoderRnn(self.feature_size, self.hidden_size,
len(vocab), self.num_layers)
# Load the trained model parameters
encoder.load_state_dict(torch.load(self.encoder_path))
decoder.load_state_dict(torch.load(self.decoder_path))
image = self.load_image(img_dir, transform)
image_tensor = self.to_var(image, volatile=True)
# If use gpu
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
# Generate caption from image
feature = encoder(image_tensor)
sampled_ids = decoder.sample(feature)
ids_arr = []
for element in sampled_ids:
temp = element.cpu().data.numpy()
ids_arr.append(int(temp))
# Decode word_ids to words
sampled_caption = []
for word_id in ids_arr:
word = vocab.idx2word[word_id]
sampled_caption.append(word)
if word == '<end>':
break
sentence = ' '.join(sampled_caption)
return sentence
# pie_caption = ImageCaptioningSample()
# pie_caption.sample('data')
def __init__(self, driving, target, time_step, split, lr, regression=True):
self.dataset = Dataset(T=time_step,
split_ratio=split,
binary_file=config.BINARY_DATASET_HEADER)
self.encoder = AttnEncoder(input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.decoder = AttnDecoder(code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
self.model = Model(self.encoder, self.decoder)
if torch.cuda.is_available():
self.encoder = self.encoder.cuda()
self.decoder = self.decoder.cuda()
self.model = self.model.cuda()
self.model_optim = optim.Adam(self.model.parameters(), lr)
# self.encoder_optim = optim.Adam(self.encoder.parameters(), lr)
# self.decoder_optim = optim.Adam(self.decoder.parameters(), lr)
if (regression):
# regression model
self.loss_func = nn.MSELoss()
else:
# classification model
weight = torch.Tensor([1, 1])
# weight = weight.cuda()
self.loss_func = nn.CrossEntropyLoss(reduce=False,
size_average=False,
weight=weight)
self.train_size, self.test_size, self.total_size = self.dataset.get_size(
)
print("train_size = %d (in terms of number of binary files)" %
self.train_size)
print("test_size = %d (in terms of number of binary files)" %
self.test_size)
class Trainer:
def __init__(self, driving, target, time_step, split, lr):
self.dataset = Dataset(driving, target, time_step, split)
self.encoder = AttnEncoder(input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.decoder = AttnDecoder(code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
if torch.cuda.is_available():
self.encoder = self.encoder.cuda()
self.decoder = self.decoder.cuda()
self.encoder_optim = optim.Adam(self.encoder.parameters(), lr)
self.decoder_optim = optim.Adam(self.decoder.parameters(), lr)
self.loss_func = nn.MSELoss()
self.train_size, self.test_size = self.dataset.get_size()
def train_minibatch(self, num_epochs, batch_size, interval):
x_train, y_train, y_seq_train = self.dataset.get_train_set()
for epoch in range(num_epochs):
i = 0
loss_sum = 0
while (i < self.train_size):
self.encoder_optim.zero_grad()
self.decoder_optim.zero_grad()
batch_end = i + batch_size
if (batch_end >= self.train_size):
batch_end = self.train_size
var_x = self.to_variable(x_train[i:batch_end])
var_y = self.to_variable(y_train[i:batch_end])
var_y_seq = self.to_variable(y_seq_train[i:batch_end])
if var_x.dim() == 2:
var_x = var_x.unsqueeze(2)
code = self.encoder(var_x)
y_res = self.decoder(code, var_y_seq)
loss = self.loss_func(y_res, var_y)
loss.backward()
self.encoder_optim.step()
self.decoder_optim.step()
# print('[%d], loss is %f' % (epoch, 10000 * loss.data[0]))
loss_sum += loss.item()
i = batch_end
print('epoch [%d] finished, the average loss is %f' %
(epoch, loss_sum))
if (epoch + 1) % (interval) == 0 or epoch + 1 == num_epochs:
torch.save(
self.encoder.state_dict(),
'models/encoder' + str(epoch + 1) + '-norm' + '.model')
torch.save(
self.decoder.state_dict(),
'models/decoder' + str(epoch + 1) + '-norm' + '.model')
def test(self, num_epochs, batch_size):
x_train, y_train, y_seq_train = self.dataset.get_train_set()
x_test, y_test, y_seq_test = self.dataset.get_test_set()
y_pred_train = self.predict(x_train, y_train, y_seq_train, batch_size)
y_pred_test = self.predict(x_test, y_test, y_seq_test, batch_size)
plt.figure(figsize=(8, 6), dpi=100)
plt.plot(range(2000, self.train_size),
y_train[2000:],
label='train truth',
color='black')
plt.plot(range(self.train_size, self.train_size + self.test_size),
y_test,
label='ground truth',
color='black')
plt.plot(range(2000, self.train_size),
y_pred_train[2000:],
label='predicted train',
color='red')
plt.plot(range(self.train_size, self.train_size + self.test_size),
y_pred_test,
label='predicted test',
color='blue')
plt.xlabel('Days')
plt.ylabel('Stock price of AAPL.US(USD)')
plt.savefig('results/res-' + str(num_epochs) + '-' + str(batch_size) +
'.png')
def predict(self, x, y, y_seq, batch_size):
y_pred = np.zeros(x.shape[0])
i = 0
while (i < x.shape[0]):
batch_end = i + batch_size
if batch_end > x.shape[0]:
batch_end = x.shape[0]
var_x_input = self.to_variable(x[i:batch_end])
var_y_input = self.to_variable(y_seq[i:batch_end])
if var_x_input.dim() == 2:
var_x_input = var_x_input.unsqueeze(2)
code = self.encoder(var_x_input)
y_res = self.decoder(code, var_y_input)
for j in range(i, batch_end):
y_pred[j] = y_res[j - i, -1]
i = batch_end
return y_pred
def load_model(self, encoder_path, decoder_path):
self.encoder.load_state_dict(
torch.load(encoder_path,
map_location=lambda storage, loc: storage))
self.decoder.load_state_dict(
torch.load(decoder_path,
map_location=lambda storage, loc: storage))
def to_variable(self, x):
if torch.cuda.is_available():
return Variable(torch.from_numpy(x).float()).cuda()
else:
return Variable(torch.from_numpy(x).float())
def main():
parser = argparse.ArgumentParser(description="Attn Encoder")
parser.add_argument("--img", type=str, help="image dir")
parser.add_argument("--prior", type=str, help="prior dir")
parser.add_argument("--csv", type=str, help="csv dir")
parser.add_argument("--conf", type=str, help="config file")
parser.add_argument("--output", type=str, help="output dir")
parser.add_argument("--pretrain", type=str, default=None, help="pretrain path")
parser.add_argument("--cont", action="store_true", help="continue training")
parser.add_argument("--epoch", type=int, default=1, help="epoch")
parser.add_argument("--optim_step_size", type=int, default=30, help="lr decay step size")
parser.add_argument("--optim_gamma", type=float, default=0.1, help="lr decay rate")
parser.add_argument("--scaling", action="store_true", help="data augmentation (scaling)")
parser.add_argument("--img_scale", type=float, default=1., nargs="+", help="image scales")
parser.add_argument("--map_scale", type=int, default=13, nargs="+", help="map scales")
args = parser.parse_args()
if not os.path.isdir(args.output):
os.makedirs(args.output)
best_path = os.path.join(args.output, "best.pth")
latest_path = os.path.join(args.output, "latest.pth")
log = os.path.join(args.output, "log")
hyper_path = os.path.join(args.output, "hyper.pth")
config = configparser.ConfigParser()
config.read(args.conf)
model_cfg, lang_cfg, img_cfg = config['MODEL'], config['LANG'], config['IMAGE']
hidden_size, attn_size, n_layers = model_cfg.getint('hidden_size'), model_cfg.getint('attn_size'), model_cfg.getint('n_layers')
prior_gamma = model_cfg.getfloat('prior_gamma')
learning_rate = model_cfg.getfloat('learning_rate')
batch_size = model_cfg.getint('batch_size')
char_list = lang_cfg['chars'] # " '&.@acbedgfihkjmlonqpsrutwvyxz"
immean, imstd = [float(x) for x in config['IMAGE']['immean'].split(',')], [float(x) for x in config['IMAGE']['imstd'].split(',')] # [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]
upper_len = model_cfg.getint('upper_length')
clip = model_cfg.getfloat('clip')
save_interval = model_cfg.getint('interval')
epochs = args.epoch
optim_step_size, optim_gamma = args.optim_step_size, args.optim_gamma
train_csv, dev_csv = os.path.join(args.csv, 'train.csv'), os.path.join(args.csv, 'dev.csv')
device, cpu = torch.device('cuda'), torch.device('cpu')
vocab_map, inv_vocab_map, char_list = utils.get_ctc_vocab(char_list)
if type(args.img_scale) == list and type(args.map_scale) == list:
scale_range, hw_range = args.img_scale, [(x, x) for x in args.map_scale]
elif type(args.img_scale) == float and type(args.map_scale) == int:
scale_range, hw_range = [args.img_scale], [(args.map_scale, args.map_scale)]
else:
raise AttributeError('scale: list or float/int')
if not args.scaling:
tsfm_train = transforms.Compose([dataset.ToTensor(device), dataset.Rescale(scale_range, hw_range, origin_scale=True), dataset.Normalize(immean, imstd, device)])
tsfm_test = transforms.Compose([dataset.ToTensor(device), dataset.Rescale(scale_range, hw_range, origin_scale=True), dataset.Normalize(immean, imstd, device)])
else:
# scale_range = [1] # [1, 0.8, 1.2] # [1, 0.8]
# hw_range = [(13, 13)] # [(13, 13), (10, 10), (15, 15)] # [(13, 13), (10, 10)]
tsfm_train = transforms.Compose([dataset.ToTensor(device), dataset.Rescale(scale_range, hw_range), dataset.Normalize(immean, imstd, device)])
tsfm_test = transforms.Compose([dataset.ToTensor(device), dataset.Rescale(scale_range, hw_range, origin_scale=True), dataset.Normalize(immean, imstd, device)])
sld_train_data = dataset.SLData(args.img, args.prior, train_csv, vocab_map, transform=tsfm_train, upper_len=upper_len)
sld_dev_data = dataset.SLData(args.img, args.prior, dev_csv, vocab_map, transform=tsfm_test, upper_len=float('inf')) # dataset.Rescale([1], [(13, 13)])
encoder = AttnEncoder(hidden_size=hidden_size, attn_size=attn_size,
output_size=len(char_list), n_layers=n_layers,
prior_gamma=prior_gamma, pretrain=args.pretrain)
encoder.to(device)
if torch.cuda.device_count() > 1:
print('Using %d GPUs' % (torch.cuda.device_count()))
encoder = nn.DataParallel(encoder)
hypers = {'step': 0, 'epoch': 0, 'best_dev_acc': -1, 'perm': np.random.permutation(len(sld_train_data)).tolist()}
if args.cont:
print("Load %s, %s" % (latest_path, hyper_path))
encoder.load_state_dict(torch.load(latest_path))
try:
with open(hyper_path, 'rb') as fo:
hypers = pickle.load(fo)
except Exception as err:
print("Error loading %s: %s" % (hyper_path, err))
hypers = {'step': 0, 'epoch': 0, 'best_dev_acc': -1, 'perm': np.random.permutation(len(sld_train_data)).tolist()}
train_loader = tud.DataLoader(sld_train_data, batch_size=batch_size, shuffle=True, collate_fn=dataset.collate_fn_ctc)
dev_loader = tud.DataLoader(sld_dev_data, batch_size=batch_size, shuffle=False, collate_fn=dataset.collate_fn_ctc)
print('Optimizer, decay %.5f after %d epochs' % (optim_gamma, optim_step_size))
cnn_optimizer = optim.SGD(encoder.conv.parameters(), lr=learning_rate)
lstm_optimizer = optim.SGD(list(encoder.encoder_cell.parameters())+list(encoder.lt.parameters()), lr=learning_rate)
cnn_scheduler = optim.lr_scheduler.StepLR(cnn_optimizer, step_size=optim_step_size, gamma=optim_gamma)
lstm_scheduler = optim.lr_scheduler.StepLR(lstm_optimizer, step_size=optim_step_size, gamma=optim_gamma)
decoder = Decoder(char_list)
ctc_loss = CTCLoss() # normalize over batch
print('%d training epochs' % (epochs))
for ep in range(epochs):
cnn_scheduler.step()
lstm_scheduler.step()
if ep < hypers['epoch']:
continue
for p in cnn_optimizer.param_groups:
print('CNN', p['lr'])
for p in lstm_optimizer.param_groups:
print('LSTM', p['lr'])
train(encoder, train_loader, clip, hypers, cnn_optimizer, lstm_optimizer, ctc_loss, decoder, log, latest_path, hyper_path, device, save_interval)
dl, dacc = evaluate(encoder, dev_loader, ctc_loss, decoder, device)
pcont = 'Epoch %d, dev loss: %.3f, dev acc (LEV): %.3f' % (ep, dl, dacc)
print(pcont)
with open(log, 'a+') as fo:
fo.write(pcont+"\n")
# save model and hyperparameter setting
hypers['epoch'] = ep
if hypers['best_dev_acc'] < dacc:
hypers['best_dev_acc'] = dacc
with open(best_path, 'wb') as fo:
torch.save(encoder.state_dict(), fo)
with open(hyper_path, 'wb') as fo:
pickle.dump(hypers, fo)
return
class Trainer:
def __init__(self, time_step, split, lr):
self.dataset = Dataset(T=time_step,
split_ratio=split,
binary_file=config.BINARY_DATASET)
self.encoder = AttnEncoder(input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.decoder = AttnDecoder(code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
self.model = Model(self.encoder, self.decoder)
if torch.cuda.is_available():
self.encoder = self.encoder.cuda()
self.decoder = self.decoder.cuda()
self.model = self.model.cuda()
self.model_optim = optim.Adam(self.model.parameters(), lr)
# self.encoder_optim = optim.Adam(self.encoder.parameters(), lr)
# self.decoder_optim = optim.Adam(self.decoder.parameters(), lr)
self.loss_func = nn.MSELoss()
self.train_size, self.test_size = self.dataset.get_size()
def train_minibatch(self, num_epochs, batch_size, interval):
x_train, y_train, y_seq_train = self.dataset.get_train_set()
for epoch in range(num_epochs):
max_acc = 0
i = 0
loss_sum = 0
while (i < self.train_size):
self.model_optim.zero_grad()
batch_end = i + batch_size
if (batch_end >= self.train_size):
break
var_x = self.to_variable(x_train[i:batch_end])
var_y = self.to_variable(y_train[i:batch_end])
var_y_seq = self.to_variable(y_seq_train[i:batch_end])
if var_x.dim() == 2:
var_x = var_x.unsqueeze(2)
y_res, y_var = self.model(var_x, var_y_seq)
loss = self.loss_func(y_res, var_y)
loss.backward()
self.model_optim.step()
print('[%d], loss is %f' % (epoch, 10000 * loss.data[0]))
loss_sum += loss.data.item()
i = batch_end
print('epoch [%d] finished, the average loss is %f' %
(epoch, loss_sum))
x_dev, y_dev, y_seq_dev = self.dataset.get_dev_set()
y_pred_dev = self.predict(x_dev, y_dev, y_seq_dev, batch_size)
acc = direction_correctness(y_pred_test=y_pred_dev, y_test=y_dev)
if (acc > max_acc):
max_acc = acc
elif acc < max_acc * 0.9: #prevent overfit
break
if (epoch + 1) % (interval) == 0 or epoch + 1 == num_epochs:
torch.save(self.encoder.state_dict(),
'models/encoder' + str(epoch + 1) + '.model')
torch.save(self.decoder.state_dict(),
'models/decoder' + str(epoch + 1) + '.model')
def test(self, num_epochs, batch_size):
x_test, y_test, y_seq_test = self.dataset.get_test_set()
y_pred_test = self.predict(x_test, y_seq_test, batch_size)
f = open('y_test', 'wb')
pickle.dump(y_test, f)
f.close()
f = open('y_pred_test', 'wb')
pickle.dump(y_pred_test, f)
f.close()
# plt.figure()
# plt.ylim(0,1)
# # plt.plot(range(1, 1 + self.train_size), y_train, label='train')
# plt.plot(range(1 + self.train_size, 1 + self.train_size + self.test_size//50), y_test[:self.test_size//50], label='ground truth')
# # plt.plot(range(1, 1 + self.train_size), y_pred_train, label.='predicted train')
# plt.plot(range(1 + self.train_size, 1 + self.train_size + self.test_size//50), y_pred_test[:self.test_size//50], label='predicted test')
# plt.savefig('res-' + str(num_epochs) + '.png')
def predict(self, x, y_seq, batch_size):
y_pred = np.zeros(x.shape[0])
i = 0
while (i < x.shape[0]):
batch_end = i + batch_size
if batch_end > x.shape[0]:
break
#batch_end = x.shape[0]
var_x_input = self.to_variable(x[i:batch_end])
var_y_input = self.to_variable(y_seq[i:batch_end])
if var_x_input.dim() == 2:
var_x_input = var_x_input.unsqueeze(2)
# code = self.encoder(var_x_input)
# y_res = self.decoder(code, var_y_input)
y_res, _ = self.model(var_x_input, var_y_input)
for j in range(i, batch_end):
y_pred[j] = y_res[j - i]
i = batch_end
return y_pred
def single_predict(self, x, y_seq):
var_x_input = self.to_variable(x)
var_y_input = self.to_variable(y_seq)
if var_x_input.dim() == 2:
var_x_input = var_x_input.unsqueeze(2)
y_res, _ = self.model(var_x_input, var_y_input)
return y_res
def load_model(self, encoder_path, decoder_path):
self.encoder.load_state_dict(
torch.load(encoder_path,
map_location=lambda storage, loc: storage))
self.decoder.load_state_dict(
torch.load(decoder_path,
map_location=lambda storage, loc: storage))
self.model = Model(self.encoder, self.decoder)
def to_variable(self, x):
if torch.cuda.is_available():
return Variable(torch.from_numpy(x).float()).cuda()
else:
return Variable(torch.from_numpy(x).float())
def main():
parser = argparse.ArgumentParser(description="Attn Encoder")
parser.add_argument("--img", type=str, help="image dir")
parser.add_argument("--prior", type=str, help="prior dir")
parser.add_argument("--csv", type=str, help="csv dir")
parser.add_argument("--conf", type=str, help="config file")
parser.add_argument("--output", type=str, help="output dir")
parser.add_argument("--model", type=str, help="model path")
parser.add_argument("--partition", type=str, help="train|dev|test")
parser.add_argument("--task", type=str, help="beta|prob")
args = parser.parse_args()
if not os.path.isdir(args.output):
os.makedirs(args.output)
config = configparser.ConfigParser()
config.read(args.conf)
model_cfg, lang_cfg, img_cfg = config['MODEL'], config['LANG'], config[
'IMAGE']
hidden_size, attn_size, n_layers = model_cfg.getint(
'hidden_size'), model_cfg.getint('attn_size'), model_cfg.getint(
'n_layers')
prior_gamma = model_cfg.getfloat('prior_gamma')
batch_size = 1
char_list = lang_cfg['chars']
immean, imstd = [float(x) for x in config['IMAGE']['immean'].split(',')], [
float(x) for x in config['IMAGE']['imstd'].split(',')
]
train_csv, dev_csv, test_csv = os.path.join(args.csv,
'train.csv'), os.path.join(
args.csv,
'dev.csv'), os.path.join(
args.csv, 'test.csv')
device, cpu = torch.device('cuda'), torch.device('cpu')
vocab_map, inv_vocab_map, char_list = utils.get_ctc_vocab(char_list)
encoder = AttnEncoder(hidden_size=hidden_size,
attn_size=attn_size,
output_size=len(char_list),
n_layers=n_layers,
prior_gamma=prior_gamma,
pretrain=None)
encoder.to(device)
if torch.cuda.device_count() > 1:
print('Using %d GPUs' % (torch.cuda.device_count()))
encoder = nn.DataParallel(encoder)
print('Load model: %s' % (args.model))
encoder.load_state_dict(torch.load(args.model))
scale_range = [0]
hw_range = [(0, 0)]
tsfm = transforms.Compose([
dataset.ToTensor(device),
dataset.Rescale(scale_range, hw_range, origin_scale=True),
dataset.Normalize(immean, imstd, device)
])
train_data = dataset.SLData(args.img,
args.prior,
train_csv,
vocab_map,
transform=tsfm,
upper_len=float('inf'))
dev_data = dataset.SLData(args.img,
args.prior,
dev_csv,
vocab_map,
transform=tsfm,
upper_len=float('inf'))
test_data = dataset.SLData(args.img,
args.prior,
test_csv,
vocab_map,
transform=tsfm,
upper_len=float('inf'))
train_loader = tud.DataLoader(train_data,
batch_size=batch_size,
shuffle=False,
collate_fn=dataset.collate_fn_ctc)
dev_loader = tud.DataLoader(dev_data,
batch_size=batch_size,
shuffle=False,
collate_fn=dataset.collate_fn_ctc)
test_loader = tud.DataLoader(test_data,
batch_size=batch_size,
shuffle=False,
collate_fn=dataset.collate_fn_ctc)
if args.task == 'beta':
get_beta(encoder, [train_loader, dev_loader, test_loader], args.output,
device)
elif args.task == 'prob':
if args.partition == 'train':
loader = train_loader
elif args.partition == 'dev':
loader = dev_loader
elif args.partition == 'test':
loader = test_loader
else:
raise ValueError('partition: train|dev|test')
get_prob(encoder, loader, args.output, device)
return
class Agent:
def __init__(self, time_step, split, lr):
self.dataset = Dataset(T=time_step,
split_ratio=split,
binary_file=config.BINARY_DATASET)
self.policy_net_encoder = AttnEncoder(
input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.policy_net_decoder = AttnDecoder(
code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
self.policy_net = DQN(self.policy_net_encoder, self.policy_net_decoder)
self.target_net_encoder = AttnEncoder(
input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.target_net_decoder = AttnDecoder(
code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
self.target_net = DQN(self.target_net_encoder, self.target_net_decoder)
if torch.cuda.is_available():
self.policy_net_encoder = self.policy_net_encoder.cuda()
self.policy_net_decoder = self.policy_net_decoder.cuda()
self.target_net_encoder = self.target_net_encoder.cuda()
self.target_net_decoder = self.target_net_decoder.cuda()
self.policy_net = self.policy_net.cuda()
self.target_net = self.target_net.cuda()
self.memory = ReplayMemory(config.MEMORY_CAPACITY)
self.optimizer = optim.RMSprop(self.policy_net.parameters(), lr=lr)
def select_action(self, state, test=False):
global steps_done
sample = random.random()
eps_threshold = config.EPS_END + (
config.EPS_START - config.EPS_END) * math.exp(
-1. * steps_done / config.EPS_DECAY)
steps_done += 1
if sample > eps_threshold or test == True:
with torch.no_grad():
return self.policy_net(state).max(1)[1].view(1, 1)
else:
if torch.cuda.is_available():
return torch.tensor([[random.randint(3)]],
dtype=torch.long).cuda()
else:
return torch.tensor([[random.randint(3)]], dtype=torch.long)
def optimize_model(self):
if len(self.memory) < config.BATCH_SIZE:
return
transitions = self.memory.sample(config.BATCH_SIZE)
batch = Transition(*zip(*transitions))
state_batch = tuple([
torch.cat(
tuple([batch.state[i][j] for i in range(config.BATCH_SIZE)]))
for j in range(3)
])
action_batch = torch.cat(batch.action)
reward_batch = torch.cat(batch.reward)
next_state_batch = tuple([
torch.cat(
tuple(
[batch.next_state[i][j]
for i in range(config.BATCH_SIZE)])) for j in range(3)
])
state_action_values = self.policy_net(state_batch).gather(
1, action_batch)
next_state_values = self.target_net(next_state_batch).max(
1)[0].detach()
expected_state_action_values = (next_state_values *
config.GAMMA) + reward_batch
loss = F.smooth_l1_loss(state_action_values,
expected_state_action_values.unsqueeze(1))
self.optimizer.zero_grad()
loss.backward()
for param in self.policy_net.parameters():
if param.grad is not None:
param.grad.data.clamp_(-1, 1)
self.optimizer.step()
def load_model(self, encoder_path=None, decoder_path=None, DQN_path=None):
if (DQN_path != None):
self.policy_net.load_state_dict(
torch.load(DQN_path,
map_location=lambda storage, loc: storage))
self.target_net.load_state_dict(self.policy_net.state_dict())
else:
self.policy_net_encoder.load_state_dict(
torch.load(encoder_path,
map_location=lambda storage, loc: storage))
self.policy_net_decoder.load_state_dict(
torch.load(decoder_path,
map_location=lambda storage, loc: storage))
self.policy_net = DQN(self.policy_net_encoder,
self.policy_net_decoder)
self.target_net.load_state_dict(self.policy_net.state_dict())
def train(self, num_epochs, interval):
env = Environment(np.array([0.5, 0.5]))
episode = 0
for epoch in range(num_epochs):
env.reset()
state = (env.x[env.current_step].unsqueeze(0),
env.y_seq[env.current_step].unsqueeze(0),
env.position.unsqueeze(0))
while (1):
action = self.select_action(state)
_, next_state, reward = env.step(action.item())
if (next_state == None):
break
self.memory.push(state, action, next_state, reward)
state = next_state
self.optimize_model()
episode += 1
if (episode % config.TARGET_UPDATE == 0):
self.target_net.load_state_dict(
self.policy_net.state_dict())
print(env.wealth, action, env.position)
if (epoch + 1) % (interval) == 0 or epoch + 1 == num_epochs:
torch.save(self.policy_net.state_dict(),
'models/DQN' + str(epoch + 1) + '.model')
def test(self, num_epochs):
env = Environment(test=True)
state = (env.x[env.current_step], env.y_seq[env.current_step],
env.position)
while (1):
action = self.select_action(state, test=True)
_, next_state, _ = env.step(action.item())
if (next_state == None):
break
state = next_state
print(env.wealth)
def main(args):
# Create model directory
if not os.path.exists(args.model_path):
os.makedirs(args.model_path)
# Image preprocessing
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.033, 0.032, 0.033), (0.027, 0.027, 0.027))
])
#Build vocab
vocab = build_vocab(args.root_path, threshold=0)
vocab_path = args.vocab_path
with open(vocab_path, 'wb') as f:
pickle.dump(vocab, f)
# with open(args.vocab_path, 'rb') as f:
# vocab = pickle.load(f)
print(vocab.idx2word)
len_vocab = vocab.idx
# Build data loader
data_loader = get_loader(args.root_path,
vocab,
transform,
args.batch_size,
shuffle=True,
num_workers=args.num_workers)
# Build the attn models
encoder = AttnEncoder(ResidualBlock, [3, 3, 3])
decoder = AttnDecoderRnn(args.feature_size, args.hidden_size, len(vocab),
args.num_layers)
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
# Loss and Optimizer
criterion = nn.CrossEntropyLoss()
params = list(decoder.parameters()) + list(encoder.parameters())
optimizer = torch.optim.Adam(params, lr=args.learning_rate)
# Train the Models
total_step = len(data_loader)
for epoch in range(args.num_epochs):
for i, (images, captions, lengths) in enumerate(data_loader):
# to variable
images = to_var(images)
captions = to_var(captions)
# Forward, Backward and Optimize
optimizer.zero_grad()
features = encoder(images)
outputs = decoder(features, captions, lengths)
captions = captions.view(-1)
outputs = outputs.view(-1, len_vocab)
loss = criterion(outputs, captions)
loss.backward()
optimizer.step()
# Print log info
if i % args.log_step == 0:
print(
'Epoch [%d/%d], Step [%d/%d], Loss: %.4f, Perplexity: %5.4f'
% (epoch, args.num_epochs, i, total_step, loss.data[0],
np.exp(loss.data[0])))
#test set accuracy
#print(outputs.view(args.batch_size,-1))
#print(outputs.max(1)[1].view(args.batch_size, -1))
outputs_np = outputs.max(1)[1].cpu().data.numpy()
targets_np = captions.cpu().data.numpy()
# print(outputs_np)
# print(targets_np)
location_match = 0
size_match = 0
shape_match = 0
exact_match = 0
for i in range(len(targets_np)):
if outputs_np[i] == targets_np[i]:
exact_match += 1
if i >= args.batch_size and i < args.batch_size * 2 and outputs_np[
i] == targets_np[i]:
shape_match += 1
elif i >= args.batch_size * 2 and i < args.batch_size * 3 and outputs_np[
i] == targets_np[i]:
location_match += 1
elif i >= args.batch_size * 3 and i < args.batch_size * 4 and outputs_np[
i] == targets_np[i]:
size_match += 1
print(
'location match : %.4f, shape match : %.4f, exact_match: %.4f'
% (location_match / (args.batch_size), shape_match /
args.batch_size, exact_match / len(targets_np)))
del images, captions
# Save the models
if (i + 1) % args.save_step == 0:
torch.save(
decoder.state_dict(),
os.path.join(args.model_path,
'decoder-%d-%d.pkl' % (epoch + 1, i + 1)))
torch.save(
encoder.state_dict(),
os.path.join(args.model_path,
'encoder-%d-%d.pkl' % (epoch + 1, i + 1)))
class Trainer:
def __init__(self, driving, target, time_step, split, lr, regression=True):
self.dataset = Dataset(T=time_step,
split_ratio=split,
binary_file=config.BINARY_DATASET_HEADER)
self.encoder = AttnEncoder(input_size=self.dataset.get_num_features(),
hidden_size=config.ENCODER_HIDDEN_SIZE,
time_step=time_step)
self.decoder = AttnDecoder(code_hidden_size=config.ENCODER_HIDDEN_SIZE,
hidden_size=config.DECODER_HIDDEN_SIZE,
time_step=time_step)
self.model = Model(self.encoder, self.decoder)
if torch.cuda.is_available():
self.encoder = self.encoder.cuda()
self.decoder = self.decoder.cuda()
self.model = self.model.cuda()
self.model_optim = optim.Adam(self.model.parameters(), lr)
# self.encoder_optim = optim.Adam(self.encoder.parameters(), lr)
# self.decoder_optim = optim.Adam(self.decoder.parameters(), lr)
if (regression):
# regression model
self.loss_func = nn.MSELoss()
else:
# classification model
weight = torch.Tensor([1, 1])
# weight = weight.cuda()
self.loss_func = nn.CrossEntropyLoss(reduce=False,
size_average=False,
weight=weight)
self.train_size, self.test_size, self.total_size = self.dataset.get_size(
)
print("train_size = %d (in terms of number of binary files)" %
self.train_size)
print("test_size = %d (in terms of number of binary files)" %
self.test_size)
def train_minibatch(self,
num_epochs,
batch_size,
interval,
cout,
regression=True):
#x_train, y_train, y_seq_train = self.dataset.get_train_set()
already_trained = 100
best_model = -1
best_correctness = 0
for epoch in range(num_epochs):
for file_num in range(self.train_size):
x_train, y_train, y_seq_train = self.dataset.get_train_set(
file_num)
i = 0
loss_sum = 0
while (i < config.MAX_SINGLE_FILE_LINE_NUM):
# self.encoder_optim.zero_grad()
# self.decoder_optim.zero_grad()
self.model_optim.zero_grad()
batch_end = i + batch_size
if (config.SPLIT_RATIO != 1.0
and file_num == self.train_size - 1 and batch_end >
(config.MAX_SINGLE_FILE_LINE_NUM -
config.VALIDATION_LINE_NUM)):
break
if (batch_end > config.MAX_SINGLE_FILE_LINE_NUM):
break
#batch_end = self.train_size
var_x = self.to_variable(x_train[i:batch_end])
var_y = Variable(
torch.from_numpy(y_train[i:batch_end]).float())
var_y_seq = self.to_variable(y_seq_train[i:batch_end])
#making sure the driving series has 3 dimensions
if var_x.dim() == 2:
var_x = var_x.unsqueeze(2)
# code = self.encoder(var_x)
# y_res = self.decoder(code, var_y_seq)
y_res, y_var = self.model(var_x, var_y_seq)
# m = torch.distributions.Normal(loc = y_loc,scale=y_var)
# loss = torch.sum(-m.log_prob(var_y.unsqueeze(0)))
if (regression):
# regression model
loss = self.loss_func(y_res, var_y)
else:
# classiication model
var_y = var_y.long().cuda()
print("y_res.requires_grad: ")
print(y_res.requires_grad)
print("y_res.type()")
print(y_res.type())
print("y_res.shape")
print(y_res.shape)
print("var_y.requires_grad: ")
print(var_y.requires_grad)
print("var_y.type()")
print(var_y.type())
print("var_y.shape")
print(var_y.shape)
loss = self.loss_func(y_res, var_y)
loss.backward()
# self.encoder_optim.step()
# self.decoder_optim.step()
self.model_optim.step()
if cont:
print('epoch[%d], file[%d], batch[%d], loss is %f' %
(already_trained + epoch + 1, file_num,
batch_end / batch_size, 10000 * loss.data[0]))
else:
print('epoch[%d], file[%d], batch[%d], loss is %f' %
(epoch + 1, file_num, batch_end / batch_size,
10000 * loss.data[0]))
loss_sum += loss.data.item()
i = batch_end
if cont:
print('epoch [%d] finished, the average loss is %f' %
(already_trained + epoch + 1, loss_sum))
if (epoch + 1) % (interval) == 0 or epoch + 1 == (
num_epochs + already_trained):
torch.save(
self.encoder.state_dict(),
'models/30min/encoder_EURUSD_30min_multifile_with_vali'
+ str(already_trained + epoch + 1) + '.model')
torch.save(
self.decoder.state_dict(),
'models/30min/decoder_EURUSD_30min_multifile_with_vali'
+ str(already_trained + epoch + 1) + '.model')
else:
print('epoch [%d] finished, the average loss is %f' %
(epoch + 1, loss_sum))
if (epoch + 1) % (interval) == 0 or epoch + 1 == num_epochs:
torch.save(
self.encoder.state_dict(),
'models/EURUSD/encoder_EURUSD_30min_multifile_with_vali_without_normalization_final_test_new_'
+ str(epoch + 1) + '.model')
torch.save(
self.decoder.state_dict(),
'models/EURUSD/decoder_EURUSD_30min_multifile_with_vali_without_normalization_final_test_new_'
+ str(epoch + 1) + '.model')
x_vali, y_vali, y_seq_vali = self.dataset.get_validation_set()
y_pred_validation = self.predict(x_vali, y_vali, y_seq_vali,
batch_size)
seq_len = len(y_vali)
gt_direction = (y_vali[1:] - y_vali[:seq_len - 1]) > 0
pred_direction = (y_pred_validation[1:] - y_vali[:seq_len - 1]) > 0
correct = np.sum(gt_direction == pred_direction)
print('number of correct in validation set = %d' % correct)
print('length of validation set = %d' % seq_len)
correct = correct / (seq_len - 1)
if (correct > best_correctness):
best_model = epoch + 1
best_correctness = correct
print(
'epoch[%d] finished, current correctness is %f, best model so far is model %d with correctness %f'
% (epoch + 1, correct, best_model, best_correctness))
def test(self, num_epochs, batch_size):
start = self.train_size
end = self.total_size
for index in range(start, end, 1):
#print('testing on part %d' % index)
#x_train, y_train, y_seq_train = self.dataset.get_train_set(index)
x_test, y_test, y_seq_test = self.dataset.get_test_set(index)
# y_pred_train = self.predict(x_train, y_train, y_seq_train, batch_size)
# f = open('y_train','wb')
# pickle.dump(y_train,f)
# f.close()
# f = open('y_pred_train','wb')
# pickle.dump(y_pred_train,f)
# f.close()
#
y_pred_test = self.predict(x_test, y_test, y_seq_test, batch_size)
#print(y_test)
#print(y_pred_test)
f = open(
'y_test_attention_weight_observation_epoch_' +
str(num_epochs) + '_part' + str(index - start + 1), 'wb')
pickle.dump(y_test, f)
f.close()
f = open(
'y_pred_test_attention_weight_observation_epoch_' +
str(num_epochs) + '_part' + str(index - start + 1), 'wb')
pickle.dump(y_pred_test, f)
f.close()
plt.figure()
# plt.plot(range(1, 1 + self.train_size), y_train, label='train')
# plt.plot(range(1 + self.train_size, 1 + self.train_size + self.test_size//50), y_test[:self.test_size//50], label='ground truth')
plt.plot(range(
1 + index * config.MAX_SINGLE_FILE_LINE_NUM, 1 +
index * config.MAX_SINGLE_FILE_LINE_NUM + len(y_test) // 2),
y_test[:len(y_test) // 2],
label='ground truth')
# plt.plot(range(1, 1 + self.train_size), y_pred_train, label.='predicted train')
# plt.plot(range(1, 1 + self.train_size), y_pred_train, label.='predicted train')
# plt.plot(range(1 + self.train_size, 1 + self.train_size + self.test_size//50), y_pred_test[:self.test_size//50], label='predicted test')
plt.plot(range(
1 + index * config.MAX_SINGLE_FILE_LINE_NUM, 1 +
index * config.MAX_SINGLE_FILE_LINE_NUM + len(y_test) // 2),
y_pred_test[:len(y_test) // 2],
label='predicted test')
plt.legend()
plt.savefig('res-attention_weight_observation_epoch' +
str(num_epochs) + '_part_' + str(index - start + 1) +
'.png')
def predict(self, x, y, y_seq, batch_size):
y_pred = np.zeros(x.shape[0])
i = 0
while (i < x.shape[0]):
#print('testing on batch %d' % (i / batch_size))
batch_end = i + batch_size
if batch_end > x.shape[0]:
break
#batch_end = x.shape[0]
var_x_input = self.to_variable(x[i:batch_end])
var_y_input = self.to_variable(y_seq[i:batch_end])
if var_x_input.dim() == 2:
var_x_input = var_x_input.unsqueeze(2)
# code = self.encoder(var_x_input)
# y_res = self.decoder(code, var_y_input)
y_res, _ = self.model(var_x_input, var_y_input)
for j in range(i, batch_end):
y_pred[j] = y_res[j - i]
i = batch_end
return y_pred
def load_model(self, encoder_path, decoder_path):
self.encoder.load_state_dict(
torch.load(encoder_path,
map_location=lambda storage, loc: storage))
self.decoder.load_state_dict(
torch.load(decoder_path,
map_location=lambda storage, loc: storage))
self.model = Model(self.encoder, self.decoder)
def to_variable(self, x):
if torch.cuda.is_available():
return Variable(torch.from_numpy(x).float()).cuda()
else:
return Variable(torch.from_numpy(x).float())
