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())