class Solver(object): def __init__(self, config, train_loader, val_loader): self.use_cuda = torch.cuda.is_available() self.device = torch.device('cuda' if self.use_cuda else 'cpu') self.train_loader = train_loader self.val_loader = val_loader self.episodes_per_epoch = config.episodes_per_epoch self.N_way_train = config.N_way_train self.N_shot_train = config.N_shot_train self.N_query_train = config.N_query_train self.M_aug_train = config.M_aug_train self.N_way_val = config.N_way_val self.N_shot_val = config.N_shot_val self.N_query_val = config.N_query_val self.M_aug_val = config.M_aug_val self.matching_fn = config.matching_fn self.nz = config.nz self.num_epochs = config.num_epochs self.resume_iter = config.resume_iter self.lr = config.lr self.num_steps_decay = config.num_steps_decay self.beta1 = config.beta1 self.beta2 = config.beta2 self.weight_decay = config.weight_decay self.exp_name = config.name os.makedirs(config.ckp_dir, exist_ok=True) self.ckp_dir = os.path.join(config.ckp_dir, self.exp_name) os.makedirs(self.ckp_dir, exist_ok=True) self.log_interval = config.log_interval self.ckp_interval = config.ckp_interval self.use_wandb = config.use_wandb self.build_model() def build_model(self): self.cnn = Convnet().to(self.device) self.g = Hallucinator(self.nz).to(self.device) self.mlp = MLP().to(self.device) self.optimizer = torch.optim.AdamW(list(self.cnn.parameters()) + list(self.g.parameters()) + list(self.mlp.parameters()), lr=self.lr, betas=[self.beta1, self.beta2], weight_decay=self.weight_decay) if self.matching_fn == 'parametric': self.parametric = nn.Sequential(nn.Linear(800, 400), nn.ReLU(), nn.Dropout(), nn.Linear(400, 1)).to(self.device) self.optimizer = torch.optim.AdamW( list(self.cnn.parameters()) + list(self.g.parameters()) + list(self.mlp.parameters()) + list(self.parametric.parameters()), lr=self.lr, betas=[self.beta1, self.beta2], weight_decay=self.weight_decay) self.scheduler = StepLR(self.optimizer, step_size=self.num_steps_decay, gamma=0.9) def save_checkpoint(self, step): state = { 'cnn': self.cnn.state_dict(), 'g': self.g.state_dict(), 'mlp': self.mlp.state_dict(), 'optimizer': self.optimizer.state_dict() } if self.matching_fn == 'parametric': state['parametric'] = self.parametric.state_dict() new_checkpoint_path = os.path.join(self.ckp_dir, '{}-dhm.pth'.format(step + 1)) torch.save(state, new_checkpoint_path) print('model saved to %s' % new_checkpoint_path) def load_checkpoint(self, resume_iter): print('Loading the trained models from step {}...'.format(resume_iter)) new_checkpoint_path = os.path.join(self.ckp_dir, '{}-dhm.pth'.format(resume_iter)) state = torch.load(new_checkpoint_path) self.cnn.load_state_dict(state['cnn']) self.g.load_state_dict(state['g']) self.mlp.load_state_dict(state['mlp']) self.optimizer.load_state_dict(state['optimizer']) if self.matching_fn == 'parametric': self.parametric.load_state_dict(state['parametric']) print('model loaded from %s' % new_checkpoint_path) def train(self): criterion = nn.CrossEntropyLoss() best_mean = 0 iteration = 0 self.sample_idx_val = [] self.noise_val = [] for i in range(self.episodes_per_epoch): self.sample_idx_val.append( torch.tensor([ torch.randint(self.N_shot_val * i, self.N_shot_val * (i + 1), (self.M_aug_val, )).numpy() for i in range(self.N_way_val) ]).reshape(-1)) self.noise_val.append( torch.randn((self.N_way_val * self.M_aug_val, self.nz), device=self.device)) if self.resume_iter: print("resuming step %d ..." % self.resume_iter) iteration = self.resume_iter self.load_checkpoint(self.resume_iter) loss, mean, std = self.eval() if mean > best_mean: best_mean = mean episodic_acc = [] for ep in range(self.num_epochs): self.cnn.train() self.g.train() self.mlp.train() for batch_idx, (data, target) in enumerate(self.train_loader): data = data.to(self.device) self.optimizer.zero_grad() support_input = data[:self.N_way_train * self.N_shot_train, :, :, :] query_input = data[self.N_way_train * self.N_shot_train:, :, :, :] label_encoder = { target[i * self.N_shot_train]: i for i in range(self.N_way_train) } query_label = torch.cuda.LongTensor([ label_encoder[class_name] for class_name in target[self.N_way_train * self.N_shot_train:] ]) support = self.cnn(support_input) queries = self.cnn(query_input) sample_idx = torch.tensor([ torch.randint(self.N_shot_train * i, self.N_shot_train * (i + 1), (self.M_aug_train, )).numpy() for i in range(self.N_way_train) ]).reshape(-1) sample = support[sample_idx] noise = torch.randn( (self.N_way_train * self.M_aug_train, self.nz), device=self.device) support_g = self.g(sample, noise).reshape(self.N_way_train, self.M_aug_train, -1) support = support.reshape(self.N_way_train, self.N_shot_train, -1) support_aug = torch.cat([support, support_g], dim=1) support_aug = support_aug.reshape( self.N_way_train * (self.N_shot_train + self.M_aug_train), -1) prototypes = self.mlp(support_aug) prototypes = prototypes.reshape( self.N_way_train, self.N_shot_train + self.M_aug_train, -1).mean(dim=1) queries = self.mlp(queries) if self.matching_fn == 'parametric': distances = pairwise_distances(queries, prototypes, self.matching_fn, self.parametric) else: distances = pairwise_distances(queries, prototypes, self.matching_fn) loss = criterion(-distances, query_label) loss.backward() self.optimizer.step() y_pred = (-distances).softmax(dim=1).max(1, keepdim=True)[1] episodic_acc.append( 1. * y_pred.eq(query_label.view_as(y_pred)).sum().item() / len(query_label)) if (iteration + 1) % self.log_interval == 0: episodic_acc = np.array(episodic_acc) mean = episodic_acc.mean() std = episodic_acc.std() print( 'Epoch: {:3d} [{:d}/{:d}]\tIteration: {:5d}\tLoss: {:.6f}\tAccuracy: {:.2f} +- {:.2f} %' .format( ep, (batch_idx + 1), len(self.train_loader), iteration + 1, loss.item(), mean * 100, 1.96 * std / (self.log_interval)**(1 / 2) * 100)) if self.use_wandb: import wandb wandb.log( { "loss": loss.item(), "acc_mean": mean * 100, "acc_ci": 1.96 * std / (self.log_interval)**(1 / 2) * 100, 'lr': self.optimizer.param_groups[0]['lr'] }, step=iteration + 1) episodic_acc = [] if (iteration + 1) % self.ckp_interval == 0: loss, mean, std = self.eval() if mean > best_mean: best_mean = mean self.save_checkpoint(iteration) if self.use_wandb: wandb.run.summary[ "best_accuracy"] = best_mean * 100 if self.use_wandb: import wandb wandb.log( { "val_loss": loss, "val_acc_mean": mean * 100, "val_acc_ci": 1.96 * std / (600)**(1 / 2) * 100 }, step=iteration + 1, commit=False) iteration += 1 self.scheduler.step() self.save_checkpoint(iteration) def eval(self): criterion = nn.CrossEntropyLoss() self.cnn.eval() self.g.eval() self.mlp.eval() episodic_acc = [] loss = [] with torch.no_grad(): for b_idx, (data, target) in enumerate(self.val_loader): data = data.to(self.device) support_input = data[:self.N_way_val * self.N_shot_val, :, :, :] query_input = data[self.N_way_val * self.N_shot_val:, :, :, :] label_encoder = { target[i * self.N_shot_val]: i for i in range(self.N_way_val) } query_label = torch.cuda.LongTensor([ label_encoder[class_name] for class_name in target[self.N_way_val * self.N_shot_val:] ]) support = self.cnn(support_input) queries = self.cnn(query_input) sample_idx = self.sample_idx_val[b_idx] sample = support[sample_idx] noise = self.noise_val[b_idx] support_g = self.g(sample, noise).reshape(self.N_way_val, self.M_aug_val, -1) support = support.reshape(self.N_way_val, self.N_shot_val, -1) support_aug = torch.cat([support, support_g], dim=1) support_aug = support_aug.reshape( self.N_way_val * (self.N_shot_val + self.M_aug_val), -1) prototypes = self.mlp(support_aug) prototypes = prototypes.reshape( self.N_way_val, self.N_shot_val + self.M_aug_val, -1).mean(dim=1) queries = self.mlp(queries) if self.matching_fn == 'parametric': distances = pairwise_distances(queries, prototypes, self.matching_fn, self.parametric) else: distances = pairwise_distances(queries, prototypes, self.matching_fn) loss.append(criterion(-distances, query_label).item()) y_pred = (-distances).softmax(dim=1).max(1, keepdim=True)[1] episodic_acc.append( 1. * y_pred.eq(query_label.view_as(y_pred)).sum().item() / len(query_label)) loss = np.array(loss) episodic_acc = np.array(episodic_acc) loss = loss.mean() mean = episodic_acc.mean() std = episodic_acc.std() print('\nLoss: {:.6f}\tAccuracy: {:.2f} +- {:.2f} %\n'.format( loss, mean * 100, 1.96 * std / (600)**(1 / 2) * 100)) return loss, mean, std
def main(): parser = argparse.ArgumentParser() parser.add_argument('--dataset', type=str, help='choose dataset') args = parser.parse_args() dataset = args.dataset logger.write("") logger.write(f"Current model: MLP") logger.write(f"Current dataset: {dataset}") setup_seeds(RANDOM_STATE) # Data loading train_file = osp.join(INPUT_PATH, dataset, "train.csv") test_file = osp.join(INPUT_PATH, dataset, "test.csv") train_df = pd.read_csv(train_file) test_df = pd.read_csv(test_file) columns = train_df.columns stat_columns_file = osp.join(INPUT_PATH, "stat_columns.txt") category_columns_file = osp.join(INPUT_PATH, "category_columns.txt") stat_columns = pickle_load(stat_columns_file) category_columns = pickle_load(category_columns_file) feature_columns = stat_columns + category_columns normalized_columns = [stat_columns[-2]] except_normalized_columns = [ column for column in feature_columns if column not in normalized_columns ] standard_scaler = StandardScaler() standard_scaler.fit(train_df[normalized_columns].values) train_normalized = standard_scaler.transform( train_df[normalized_columns].values) test_normalized = standard_scaler.transform( test_df[normalized_columns].values) X_train = np.concatenate( (train_normalized, train_df[except_normalized_columns].values), axis=1) y_train = train_df["target"].values X_test = np.concatenate( (test_normalized, test_df[except_normalized_columns].values), axis=1) y_test = test_df["target"].values logger.write("x_train.shape: " + str(X_train.shape)) logger.write("y_train.shape: " + str(y_train.shape)) logger.write("x_test.shape: " + str(X_test.shape)) n_features = len(feature_columns) n_category_features = len(category_columns) n_stat_features = len(stat_columns) n_classes = 1 embeds_desc = [] X_total = np.concatenate((X_train, X_test), axis=0) for i in range(n_stat_features, n_features): cur_column = X_total[:, i] num_embed = int(max(cur_column) + 1) embeds_desc.append([num_embed, 16]) # Train process logger.write("Training...") model = MLP(n_stat_features, 64, embeds_desc, n_classes, 0.1) model_path = osp.join(INPUT_PATH, "mlp", dataset) if not osp.exists(model_path): os.makedirs(model_path) model_file = osp.join(model_path, "checkpoint.pt") patience = 6 early_stopping = EarlyStopping(patience=patience, verbose=True, path=model_file) logger.write(model) train(X_train, y_train, model, n_stat_features, n_features, early_stopping) # Predict process logger.write("Predicting...") stat_matrix_test = X_test[:, :n_stat_features] embeds_input_test = [] for i in range(n_stat_features, n_features): embeds_input_test.append(X_test[:, i]) stat_matrix_test = torch.tensor(stat_matrix_test, dtype=torch.float) embeds_input_test = torch.tensor(embeds_input_test, dtype=torch.long) test_data = [stat_matrix_test, embeds_input_test] model.load_state_dict(torch.load(model_file)) y_test_prob = predict(test_data, model) # calc metrics logger.write(f"test max prob:{y_test_prob.max()}") logger.write(f"test min prob:{y_test_prob.min()}") logger.write("Metrics calculation...") recall_precision_score(y_test_prob, y_test) print("")
import torch import torch.nn as nn import numpy as np import os import pickle from data_loader import load_test_dataset from model import MLP from torch.autograd import Variable import math import time size = 5.0 # Load trained model for path generation mlp = MLP(32, 2) # simple @D mlp.load_state_dict(torch.load('models/mlp_100_4000_PReLU_ae_dd150.pkl')) if torch.cuda.is_available(): mlp.cuda() #load test dataset obc, obstacles, paths, path_lengths = load_test_dataset() def IsInCollision(x, idx): s = np.zeros(2, dtype=np.float32) s[0] = x[0] s[1] = x[1] for i in range(0, 7): cf = True for j in range(0, 2):
class DQN: def __init__(self, state_dim, action_dim, cfg): """ :param state_dim: About Task :param action_dim: About Task :param cfg: Config, About DQN setting """ self.device = cfg.device self.action_dim = action_dim self.gamma = cfg.gamma self.frame_idx = 0 # Decay count for epsilon self.epsilon = lambda frame_idx: \ cfg.epsilon_end + \ (cfg.epsilon_start - cfg.epsilon_end) * \ math.exp(-1. * frame_idx / cfg.epsilon_decay) self.batch_size = cfg.batch_size self.q_value_net = MLP(state_dim, action_dim, hidden_dim=cfg.hidden_dim).to(self.device) self.target_net = MLP(state_dim, action_dim, hidden_dim=cfg.hidden_dim).to(self.device) self.optimizer = optim.Adam(self.q_value_net.parameters(), lr=cfg.lr) self.loss = 0 self.replay_buffer = ReplayBuffer(cfg.capacity) def choose_action(self, state): # Select actions using e—greedy principle self.frame_idx += 1 if random.random() > self.epsilon(self.frame_idx): # Will not track the gradient with torch.no_grad(): # Although Q(s,a) is written in the pseudocode of the original paper, # it is actually the value of Q(s) output |A| dimension state = torch.tensor([state], device=self.device, dtype=torch.float) q_value = self.q_value_net(state) # output = torch.max(input, dim) # dim is the dimension 0/1 of the max function index, # 0 is the maximum value of each column, # 1 is the maximum value of each row # The function will return two tensors, # the first tensor is the maximum value of each row; # the second tensor is the index of the maximum value of each row. # .item(): only one element tensors can be converted to Python scalars action = q_value.max(1)[1].item() else: action = random.randrange(self.action_dim) return action def update(self): if len(self.replay_buffer) < self.batch_size: return # Randomly sample transitions from the replay buffer state_batch, action_batch, reward_batch, next_state_batch, done_batch = \ self.replay_buffer.sample(self.batch_size) state_batch = to_tensor_float(state_batch, device=self.device) # tensor([1, 2, 3, 4]).unsqueeze(1) -> tensor([[1],[2],[3],[4]]) action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1) reward_batch = to_tensor_float(reward_batch, device=self.device) next_state_batch = to_tensor_float(next_state_batch, device=self.device) done_batch = to_tensor_float(done_batch, device=self.device) # Calculate Q(s,a) at time t # q_t=Q(s_t,a_t) # Use index to index the value of a specific position in a dimension # a=torch.Tensor([[1,2],[3,4]]), # a.gather(1,torch.LongTensor([[0],[1]]))=torch.Tensor([[1],[4]]) # index action_batch is obtained from the replay buffer q_value = self.q_value_net(state_batch).gather( dim=1, index=action_batch) # shape: [32,1] # Calculate Q(s,a) at time t+1 # q_{t+1}=max_a Q(s_t+1,a) # .detach(): # Return a new Variable, which is separated from the current calculation graph, # but still points to the storage location of the original variable. # The difference is that requires grad is false. # The obtained Variable never needs to calculate its gradient and does not have grad. # # Even if it re-sets its requirements grad to true later, # it will not have a gradient grad next_q_value = self.target_net(next_state_batch).max(1)[0].detach() # For the termination state, the corresponding expected_q_value is equal to reward expected_q_value = reward_batch + self.gamma * next_q_value * ( 1 - done_batch) # shape: 32 # loss_fn = torch.nn.MSELoss(reduce=True, size_average=True) # reduce = False,return loss in vector form # reduce = True, return loss in scalar form # size_average = True,return loss.mean() # size_average = False,return loss.sum() self.loss = nn.MSELoss()(q_value, expected_q_value.unsqueeze(1)) # Sets the gradients of all optimized :class:`torch.Tensor` s to zero. self.optimizer.zero_grad() self.loss.backward() # Performs a single optimization step (parameter update). self.optimizer.step() def save(self, path): # Returns a dictionary containing a whole state of the module. # Both parameters and persistent buffers (e.g. running averages) are included. # Keys are corresponding parameter and buffer names. torch.save(self.target_net.state_dict(), path + "dqn_checkpoint.pth") def load(self, path): self.target_net.load_state_dict(torch.load(path + "dqn_checkpoint.pth"))
class Test(): def __init__(self, config_path): config = configparser.ConfigParser() config.read(config_path) self.save_dir = Path(config.get("general", "save_dir")) if not self.save_dir.exists(): self.save_dir.mkdir(parents=True) self.clf_th = config.getfloat("general", "clf_th") self.mlp_model_path = config.get("model", "mlp") assert Path(self.mlp_model_path).exists() self.device = "cuda" if torch.cuda.is_available() else "cpu" bert_config_path = config.get("bert", "config_path") assert Path(bert_config_path).exists() self.bert_config = LongformerConfig.from_json_file(bert_config_path) self.max_seq_length = self.bert_config.max_position_embeddings - 2 self.bert_tokenizer = LongformerTokenizer.from_pretrained( 'allenai/longformer-base-4096') # bert_tokenizer_path = config.get("bert", "tokenizer_path") # assert Path(bert_config_path).exists() # self.bert_tokenizer = LongformerTokenizer.from_pretrained(bert_tokenizer_path) bert_model_path = config.get("bert", "model_path") assert Path(bert_model_path).exists() self.bert_model = LongformerModel.from_pretrained( bert_model_path, config=self.bert_config) self.bert_model.to(self.device) self.bert_model.eval() gold_dir = Path(config.get("data", "gold_dir")) assert Path(gold_dir).exists() self.gold_dataset = ConllDataset(gold_dir) target_dir = Path(config.get("data", "target_dir")) assert Path(target_dir).exists() self.target_dataset = ConllDataset(target_dir) def transforms(self, example, label_list, is_gold): feature = convert_single_example(example, label_list, self.max_seq_length, self.bert_tokenizer) label_ids = feature.label_ids label_map = feature.label_map if is_gold: gold_labels = [-1] * self.max_seq_length # Get "Element" or "Main" token indices for i, lid in enumerate(label_ids): if lid == label_map['B-Element']: gold_labels[i] = 0 elif lid == label_map['B-Main']: gold_labels[i] = 1 elif lid in (label_map['I-Element'], label_map['I-Main']): gold_labels[i] = 2 elif lid == label_map['X']: gold_labels[i] = 3 gold_labels = gold_labels else: gold_labels = [-1] * self.max_seq_length # Get "Element" or "Main" token indices for i, lid in enumerate(label_ids): if lid == label_map['B-Element']: gold_labels[i] = 0 elif lid == label_map['I-Element']: gold_labels[i] = 2 elif lid == label_map['X']: gold_labels[i] = 3 gold_labels = gold_labels # flush data to bert model input_ids = torch.tensor(feature.input_ids).unsqueeze(0).to( self.device) with torch.no_grad(): bert_output = self.bert_model(input_ids) # lstm (ignore padding parts) bert_fv = bert_output[0] input_ids = torch.tensor(feature.input_ids) label_ids = torch.tensor(feature.label_ids) return bert_fv, input_ids, label_ids, label_map, gold_labels def load_model(self): # MLP self.mlp = MLP(self.bert_config.hidden_size) self.mlp.load_state_dict(torch.load(self.mlp_model_path)) self.mlp.to(self.device) self.mlp.eval() def eval(self): self.load_model() correct_save_dir = self.save_dir / "correct" if not correct_save_dir.exists(): correct_save_dir.mkdir(parents=True) incorrect_save_dir = self.save_dir / "incorrect" if not incorrect_save_dir.exists(): incorrect_save_dir.mkdir(parents=True) tp, fp, tn, fn = 0, 0, 0, 0 with torch.no_grad(): for gold_data, target_data in tqdm( zip(self.gold_dataset, self.target_dataset)): # flush to Bert gold_fname, gold_example = gold_data target_fname, target_example = target_data if not gold_fname == target_fname: import pdb pdb.set_trace() assert gold_fname == target_fname _, _, _, _, gold_labels = self.transforms( gold_example, self.gold_dataset.label_list, is_gold=True) fvs, input_ids, label_ids, label_map, pred_labels = self.transforms( target_example, self.target_dataset.label_list, is_gold=False) # extract Element/Main tokens is_correct = True _, ent_gold_labels, golds_mask = Trainer.extract_tokens( fvs.squeeze(0), gold_labels) golds = {} if len(ent_gold_labels) >= 1: i = 0 while True: try: ent_start = golds_mask.index(i) except ValueError: break for n, j in enumerate(golds_mask[ent_start:]): if j != i: ent_end = (ent_start + n - 1) break golds[(ent_start, ent_end)] = ent_gold_labels[i] i += 1 ents, ent_pred_labels, preds_mask = Trainer.extract_tokens( fvs.squeeze(0), pred_labels) preds = {} if len(ent_pred_labels) >= 1: i = 0 while True: try: ent_start = preds_mask.index(i) except ValueError: break for n, j in enumerate(preds_mask[ent_start:]): if j != i: ent_end = (ent_start + n - 1) break preds[(ent_start, ent_end)] = ent_pred_labels[i] i += 1 for gold_span, gold_label in golds.items(): if gold_span not in preds.keys(): if gold_label == 1: fn += 1 is_correct = False ents_pred = [0] * len(ents) for i, pred in enumerate(preds): # convert to torch.tensor inputs = torch.empty( [len(ents[i]), self.bert_config.hidden_size]).to(self.device) for j, token in enumerate(ents[i]): inputs[j, :] = token inputs = torch.mean(inputs, dim=0, keepdim=True) outputs = self.mlp(inputs) if pred in golds.keys(): target = golds[pred] if target == 1: if outputs < self.clf_th: fn += 1 is_correct = False else: tp += 1 else: if outputs < self.clf_th: tn += 1 else: fp += 1 is_correct = False else: if outputs < self.clf_th: pass else: fp += 1 is_correct = False outputs_ = outputs.to('cpu').detach().numpy().copy() if np.all(outputs_ > self.clf_th): ents_pred[i] = 1 if is_correct: save_dir = correct_save_dir else: save_dir = incorrect_save_dir save_path = save_dir / (target_fname + ".conll") lines = [] elem_cnt = -1 for i in range(len(target_example.text)): text = target_example.text[i] label = target_example.label[i] start = target_example.start[i] end = target_example.end[i] if label == "B-Element": elem_cnt += 1 if ents_pred[elem_cnt] == 1: lines.append(f"B-Main\t{start}\t{end}\t{text}") elif ents_pred[elem_cnt] == 0: lines.append(f"{label}\t{start}\t{end}\t{text}") elif label == "I-Element": if ents_pred[elem_cnt] == 1: lines.append(f"I-Main\t{start}\t{end}\t{text}") elif ents_pred[elem_cnt] == 0: lines.append(f"{label}\t{start}\t{end}\t{text}") else: lines.append(f"{label}\t{start}\t{end}\t{text}") with save_path.open("w") as f: f.write("\n".join(lines)) return Score(tp, fp, tn, fn).calc_score()
def main(opt): train_dataset = BADataset(opt.dataroot, opt.L, True, False, False) train_dataloader = BADataloader(train_dataset, batch_size=opt.batchSize, \ shuffle=True, num_workers=opt.workers, drop_last=True) valid_dataset = BADataset(opt.dataroot, opt.L, False, True, False) valid_dataloader = BADataloader(valid_dataset, batch_size=opt.batchSize, \ shuffle=True, num_workers=opt.workers, drop_last=True) test_dataset = BADataset(opt.dataroot, opt.L, False, False, True) test_dataloader = BADataloader(test_dataset, batch_size=opt.batchSize, \ shuffle=True, num_workers=opt.workers, drop_last=True) all_dataset = BADataset(opt.dataroot, opt.L, False, False, False) all_dataloader = BADataloader(all_dataset, batch_size=opt.batchSize, \ shuffle=False, num_workers=opt.workers, drop_last=False) opt.n_edge_types = train_dataset.n_edge_types opt.n_node = train_dataset.n_node net = MLP(opt) net.double() print(net) criterion = nn.BCELoss() if opt.cuda: net.cuda() criterion.cuda() optimizer = optim.Adam(net.parameters(), lr=opt.lr) early_stopping = EarlyStopping(patience=opt.patience, verbose=True) os.makedirs(OutputDir, exist_ok=True) train_loss_ls = [] valid_loss_ls = [] test_loss_ls = [] for epoch in range(0, opt.niter): train_loss = train(epoch, train_dataloader, net, criterion, optimizer, opt) valid_loss = valid(valid_dataloader, net, criterion, opt) test_loss = test(test_dataloader, net, criterion, opt) train_loss_ls.append(train_loss) valid_loss_ls.append(valid_loss) test_loss_ls.append(test_loss) early_stopping(valid_loss, net, OutputDir) if early_stopping.early_stop: print("Early stopping") break df = pd.DataFrame({ 'epoch': [i for i in range(1, len(train_loss_ls) + 1)], 'train_loss': train_loss_ls, 'valid_loss': valid_loss_ls, 'test_loss': test_loss_ls }) df.to_csv(OutputDir + '/loss.csv', index=False) net.load_state_dict(torch.load(OutputDir + '/checkpoint.pt')) inference(all_dataloader, net, criterion, opt, OutputDir)
class DQN: def __init__(self, n_states, n_actions, gamma=0.99, epsilon_start=0.9, epsilon_end=0.05, epsilon_decay=200, memory_capacity=10000, policy_lr=0.01, batch_size=128, device="cpu"): self.actions_count = 0 self.n_actions = n_actions # 总的动作个数 self.device = device # 设备,cpu或gpu等 self.gamma = gamma # e-greedy策略相关参数 self.epsilon = 0 self.epsilon_start = epsilon_start self.epsilon_end = epsilon_end self.epsilon_decay = epsilon_decay self.batch_size = batch_size self.policy_net = MLP(n_states, n_actions).to(self.device) self.target_net = MLP(n_states, n_actions).to(self.device) # target_net的初始模型参数完全复制policy_net self.target_net.load_state_dict(self.policy_net.state_dict()) self.target_net.eval() # 不启用 BatchNormalization 和 Dropout # 可查parameters()与state_dict()的区别,前者require_grad=True self.optimizer = optim.Adam(self.policy_net.parameters(), lr=policy_lr) self.loss = 0 self.memory = ReplayBuffer(memory_capacity) def choose_action(self, state, train=True): '''选择动作 ''' if train: self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \ math.exp(-1. * self.actions_count / self.epsilon_decay) self.actions_count += 1 if random.random() > self.epsilon: with torch.no_grad(): # 先转为张量便于丢给神经网络,state元素数据原本为float64 # 注意state=torch.tensor(state).unsqueeze(0)跟state=torch.tensor([state])等价 state = torch.tensor([state], device=self.device, dtype=torch.float32) # 如tensor([[-0.0798, -0.0079]], grad_fn=<AddmmBackward>) q_value = self.policy_net(state) # tensor.max(1)返回每行的最大值以及对应的下标, # 如torch.return_types.max(values=tensor([10.3587]),indices=tensor([0])) # 所以tensor.max(1)[1]返回最大值对应的下标,即action action = q_value.max(1)[1].item() else: action = random.randrange(self.n_actions) return action else: with torch.no_grad(): # 先转为张量便于丢给神经网络,state元素数据原本为float64 # 注意state=torch.tensor(state).unsqueeze(0)跟state=torch.tensor([state])等价 state = torch.tensor([state], device='cpu', dtype=torch.float32) # 如tensor([[-0.0798, -0.0079]], grad_fn=<AddmmBackward>) q_value = self.target_net(state) # tensor.max(1)返回每行的最大值以及对应的下标, # 如torch.return_types.max(values=tensor([10.3587]),indices=tensor([0])) # 所以tensor.max(1)[1]返回最大值对应的下标,即action action = q_value.max(1)[1].item() return action def update(self): if len(self.memory) < self.batch_size: return # 从memory中随机采样transition state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample( self.batch_size) # 转为张量 # 例如tensor([[-4.5543e-02, -2.3910e-01, 1.8344e-02, 2.3158e-01],...,[-1.8615e-02, -2.3921e-01, -1.1791e-02, 2.3400e-01]]) state_batch = torch.tensor(state_batch, device=self.device, dtype=torch.float) action_batch = torch.tensor(action_batch, device=self.device).unsqueeze( 1) # 例如tensor([[1],...,[0]]) reward_batch = torch.tensor( reward_batch, device=self.device, dtype=torch.float) # tensor([1., 1.,...,1]) next_state_batch = torch.tensor(next_state_batch, device=self.device, dtype=torch.float) done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze( 1) # 将bool转为float然后转为张量 # 计算当前(s_t,a)对应的Q(s_t, a) q_values = self.policy_net(state_batch) next_q_values = self.policy_net(next_state_batch) # 代入当前选择的action,得到Q(s_t|a=a_t) q_value = q_values.gather(dim=1, index=action_batch) '''以下是Nature DQN的q_target计算方式 # 计算所有next states的Q'(s_{t+1})的最大值,Q'为目标网络的q函数 next_q_state_value = self.target_net( next_state_batch).max(1)[0].detach() # 比如tensor([ 0.0060, -0.0171,...,]) # 计算 q_target # 对于终止状态,此时done_batch[0]=1, 对应的expected_q_value等于reward q_target = reward_batch + self.gamma * next_q_state_value * (1-done_batch[0]) ''' '''以下是Double DQNq_target计算方式,与NatureDQN稍有不同''' next_target_values = self.target_net(next_state_batch) # 选出Q(s_t‘, a)对应的action,代入到next_target_values获得target net对应的next_q_value,即Q’(s_t|a=argmax Q(s_t‘, a)) next_target_q_value = next_target_values.gather( 1, torch.max(next_q_values, 1)[1].unsqueeze(1)).squeeze(1) q_target = reward_batch + self.gamma * next_target_q_value * ( 1 - done_batch[0]) self.loss = nn.MSELoss()(q_value, q_target.unsqueeze(1)) # 计算 均方误差loss # 优化模型 self.optimizer.zero_grad( ) # zero_grad清除上一步所有旧的gradients from the last step # loss.backward()使用backpropagation计算loss相对于所有parameters(需要gradients)的微分 self.loss.backward() for param in self.policy_net.parameters(): # clip防止梯度爆炸 param.grad.data.clamp_(-1, 1) self.optimizer.step() # 更新模型 def save_model(self, path): torch.save(self.target_net.state_dict(), path) def load_model(self, path): self.target_net.load_state_dict(torch.load(path))
import torch import torch.nn as nn import torchvision.transforms as transforms from torchvision import datasets from torch.utils.data import DataLoader from model import MLP import train criterion = nn.CrossEntropyLoss() transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) data_test = datasets.CIFAR10('/data', train=False, download=True, transform=transform) net = MLP(3 * 32 * 32, 10) PATH = './cifar_net.pth' net.load_state_dict(torch.load(PATH)) print(net) test_loader = DataLoader(data_test, num_workers=0, batch_size=4) # error with num_workers != 0 criterion = nn.CrossEntropyLoss() # accuracy computation all_labels_number = 0 all_correct_labels_number = 0 for data, label in test_loader: # print(data,label) net_out = net(data) _, label_pred = torch.max(net_out, 1) labels_in_batch = label.shape[0] correct_labels_in_batch = (label_pred == label).sum().item() all_labels_number += labels_in_batch all_correct_labels_number += correct_labels_in_batch # print(all_labels_number)
def main(): # Initialize environment env = UnityEnvironment(file_name='../env/Pong/Pong') default_brain = env.brain_names[0] brain = env.brains[default_brain] env_info = env.reset(train_mode=True)[default_brain] obs_dim = env_info.vector_observations[0].shape[0] act_num = brain.vector_action_space_size[0] print('State dimension:', obs_dim) print('Action number:', act_num) # Set a random seed np.random.seed(0) torch.manual_seed(0) # Create a SummaryWriter object by TensorBoard dir_name = 'runs/' + 'dqn/' + 'Pong_dqn' + '_' + time.ctime() writer = SummaryWriter(log_dir=dir_name) # Main network qf = MLP(obs_dim, act_num).to(device) # Target network qf_target = MLP(obs_dim, act_num).to(device) # Initialize target parameters to match main parameters qf_target.load_state_dict(qf.state_dict()) # Create an optimizer qf_optimizer = optim.Adam(qf.parameters(), lr=1e-3) # Experience buffer replay_buffer = ReplayBuffer(obs_dim, 1, args.buffer_size) step_count = 0 sum_returns = 0. num_episodes = 0 recent_returns = deque(maxlen=10) start_time = time.time() for episode in range(1, args.episode_num + 1): total_reward = 0. env_info = env.reset(train_mode=True)[default_brain] obs = env_info.vector_observations[0] done = False # Keep interacting until agent reaches a terminal state. while not done: step_count += 1 # Collect experience (s, a, r, s') using some policy action = select_action(torch.Tensor(obs).to(device), act_num, qf) env_info = env.step(int(action))[default_brain] next_obs = env_info.vector_observations[0] reward = env_info.rewards[0] done = env_info.local_done[0] # Add experience to replay buffer replay_buffer.add(obs, action, reward, next_obs, done) # Start training when the number of experience is greater than batch size if step_count > args.batch_size: batch = replay_buffer.sample(args.batch_size) train_model(qf, qf_target, qf_optimizer, batch, step_count) total_reward += reward obs = next_obs recent_returns.append(total_reward) sum_returns += total_reward num_episodes += 1 average_return = sum_returns / num_episodes if num_episodes > 0 else 0.0 # Log experiment result for training episodes writer.add_scalar('Train/AverageReturns', average_return, episode) writer.add_scalar('Train/EpisodeReturns', sum_returns, episode) if episode % 10 == 0: print('---------------------------------------') print('Episodes:', episode) print('Steps:', step_count) print('AverageReturn:', round(average_return, 2)) print('RecentReturn:', np.mean(recent_returns)) print('Time:', int(time.time() - start_time)) print('---------------------------------------') # Save a training model if (np.mean(recent_returns)) >= args.threshold_return: print('Recent returns {} exceed threshold return. So end'.format( np.mean(recent_returns))) if not os.path.exists('./save_model'): os.mkdir('./save_model') ckpt_path = os.path.join('./save_model/' + 'Pong_dqn' + '_ep_' + str(episode) \ + '_rt_' + str(round(average_return, 2)) \ + '_t_' + str(int(time.time() - start_time)) + '.pt') torch.save(qf.state_dict(), ckpt_path) break env.close()
def train_model(config, gpu_id, save_dir, exp_name): # Instantiating the model model_type = config.get('model_type', 'MLP') if model_type == "MLP": model = MLP(config['input_size'], config["hidden_layers"], 1, config["nonlinearity"], config["initialization"], config["dropout"], verbose=True) elif model_type == "CNN": model = CNN(config["initialization"], config["is_batch_norm"], verbose=True) else: raise ValueError( 'config["model_type"] not supported : {}'.format(model_type)) if config['resume']: model.load_state_dict( torch.load(os.path.join(save_dir, exp_name, "model"))) # If GPU is available, sends model and dataset on the GPU if torch.cuda.is_available(): model.cuda(gpu_id) print("USING GPU-{}".format(gpu_id)) # Optimizer and Loss Function optimizer = optim.RMSprop(model.parameters(), lr=config['lr']) loss_fn = nn.CrossEntropyLoss() """ Trains an agent with (stochastic) Policy Gradients on Pong. Uses OpenAI Gym. """ env = gym.make("Pong-v0") observation = env.reset() prev_x = None # used in computing the difference frame y_list, LL_list, reward_list = [], [], [] running_reward = None reward_sum = 0 episode_number = 0 start = time.time() # Initializing recorders update = 0 loss_tape = [] our_score_tape = [] opponent_score_tape = [] our_score = 0 opponent_score = 0 # TRAINING LOOP while update < config['max_updates']: if config['render']: env.render() # preprocess the observation and set input to network to be difference image cur_x = utils.preprocess(observation, data_format=config['data_format']) if prev_x is None: x = np.zeros(cur_x.shape) else: x = cur_x - prev_x prev_x = cur_x x_torch = Variable(torch.from_numpy(x).float(), requires_grad=False) if config['data_format'] == "array": x_torch = x_torch.unsqueeze(dim=0).unsqueeze(dim=0) if torch.cuda.is_available(): x_torch = x_torch.cuda(gpu_id) # Feedforward through the policy network action_prob = model(x_torch) # Sample an action from the returned probability if np.random.uniform() < action_prob.cpu().data.numpy(): action = 2 # UP else: action = 3 # DOWN # record the log-likelihoods y = 1 if action == 2 else 0 # a "fake label" NLL = -y * torch.log(action_prob) - (1 - y) * torch.log(1 - action_prob) LL_list.append(NLL) y_list.append( y ) # grad that encourages the action that was taken to be taken TODO: the tensor graph breaks here. Find a way to backpropagate the PG error. # step the environment and get new measurements observation, reward, done, info = env.step(action) reward_sum += reward reward_list.append( reward ) # record reward (has to be done after we call step() to get reward for previous action) if done: # an episode finished (an episode ends when one of the player wins 21 games) episode_number += 1 # Computes loss and reward for each step of the episode R = torch.zeros(1, 1) loss = 0 for i in reversed(range(len(reward_list))): R = config['gamma'] * R + reward_list[i] Return_i = Variable(R) if torch.cuda.is_available(): Return_i = Return_i.cuda(gpu_id) loss = loss + (LL_list[i] * (Return_i)).sum() # .expand_as(LL_list[i]) loss = loss / len(reward_list) print(loss) # Backpropagates to compute the gradients loss.backward() y_list, LL_list, reward_list = [], [], [] # reset array memory # Performs parameter update every config['mb_size'] episodes if episode_number % config['mb_size'] == 0: # Takes one training step optimizer.step() # Empties the gradients optimizer.zero_grad() stop = time.time() print("PARAMETER UPDATE ------------ {}".format(stop - start)) start = time.time() utils.save_results(save_dir, exp_name, loss_tape, our_score_tape, opponent_score_tape, config) update += 1 if update % 10 == 0: torch.save( model.state_dict(), os.path.join(save_dir, exp_name, "model_" + model.name())) # Records the average loss and score of the episode loss_tape.append(loss.cpu().data.numpy()) our_score_tape.append(our_score) opponent_score_tape.append(opponent_score) our_score = 0 opponent_score = 0 # boring book-keeping if running_reward is None: running_reward = reward_sum else: running_reward = running_reward * 0.99 + reward_sum * 0.01 print( 'resetting env. episode reward total was {0:.2f}. running mean: {1:.2f}' .format(reward_sum, running_reward)) reward_sum = 0 observation = env.reset() # reset env prev_x = None if reward != 0: # Pong has either +1 or -1 reward exactly when game ends. if reward == -1: opponent_score += 1 print('ep {0}: game finished, reward: {1:.2f}'.format( episode_number, reward)) else: our_score += 1 print( 'ep {0}: game finished, reward: {1:.2f} !!!!!!!!!'.format( episode_number, reward))
def test(args): # setup multiprocessing instance torch.multiprocessing.set_sharing_strategy('file_system') # setup data_loader instances if args.arch == "MLP": test_data_loader = EdgeDataLoader(mode="test", data_path=args.data, batch_size=1, shuffle=True, num_workers=4, batch_type="large_batch") elif args.arch == "DeepSetMLP": test_data_loader = SubGraphDataLoader(mode="test", data_path=args.data, batch_size=1, shuffle=True, num_workers=4, batch_type="large_batch") elif args.arch == "DeepAPGMLP": test_data_loader = AnchorParentDataLoader(mode="test", data_path=args.data, batch_size=1, shuffle=True, num_workers=4, batch_type="large_batch") # setup device device = torch.device( f'cuda:{args.device}' if torch.cuda.is_available() else 'cpu') # load model if args.arch == "MLP": model = MLP(vocab_size=29654, embed_dim=250, first_hidden=1000, second_hidden=500, activation=nn.LeakyReLU()) # model = MLP(vocab_size=431416, embed_dim=250, first_hidden=1000, second_hidden=500, activation=nn.LeakyReLU()) elif args.arch == "DeepSetMLP": model = DeepSetMLP(vocab_size=29654, embed_dim=250, first_hidden=1500, second_hidden=1000, activation=nn.LeakyReLU()) # model = DeepSetMLP(vocab_size=431416, embed_dim=250, first_hidden=1500, second_hidden=1000, activation=nn.LeakyReLU()) elif args.arch == "DeepAPGMLP": model = DeepAPGMLP(vocab_size=29654, embed_dim=250, first_hidden=2000, second_hidden=1000, activation=nn.LeakyReLU()) checkpoint = torch.load(args.resume) state_dict = checkpoint['state_dict'] model.load_state_dict(state_dict) model = model.to(device) model.eval() # get function handles of loss and metrics loss_fn = bce_loss metric_fn = [ macro_averaged_rank, batched_topk_hit_1, batched_topk_hit_3, batched_topk_hit_5, batched_scaled_MRR ] # start evaluation on test data total_loss = 0.0 total_metrics = torch.zeros(len(metric_fn)) with torch.no_grad(): for batched_examples in tqdm(test_data_loader): energy_scores = [] all_labels = [] if len(batched_examples) == 3: batched_parents, batched_children, batched_labels = batched_examples[ 0], batched_examples[1], batched_examples[2] for parents, children, labels in zip(batched_parents, batched_children, batched_labels): parents, children = parents.to(device), children.to(device) prediction = model(parents, children).to(device) loss = loss_fn(prediction, labels.to(device)) total_loss += loss.item() energy_scores.extend(prediction.squeeze_().tolist()) all_labels.extend(labels.tolist()) elif len(batched_examples) == 4: batched_parents, batched_siblings, batched_children, batched_labels = batched_examples[ 0], batched_examples[1], batched_examples[ 2], batched_examples[3] for parents, siblings, children, labels in zip( batched_parents, batched_siblings, batched_children, batched_labels): parents, siblings, children = parents.to( device), siblings.to(device), children.to(device) prediction = model(parents, siblings, children).to(device) loss = loss_fn(prediction, labels.to(device)) total_loss += loss.item() energy_scores.extend(prediction.squeeze_().tolist()) all_labels.extend(labels.tolist()) elif len(batched_examples) == 5: batched_parents, batched_siblings, batched_grand_parents, batched_children, batched_labels = batched_examples[ 0], batched_examples[1], batched_examples[ 2], batched_examples[3], batched_examples[4] for parents, siblings, grand_parents, children, labels in zip( batched_parents, batched_siblings, batched_grand_parents, batched_children, batched_labels): parents, siblings, grand_parents, children = parents.to( device), siblings.to(device), grand_parents.to( device), children.to(device) prediction = model(parents, siblings, grand_parents, children).to(device) loss = loss_fn(prediction, labels.to(device)) total_loss += loss.item() energy_scores.extend(prediction.squeeze_().tolist()) all_labels.extend(labels.tolist()) energy_scores = torch.tensor(energy_scores).unsqueeze_(1) all_labels = torch.tensor(all_labels) # computing metrics on test set for i, metric in enumerate(metric_fn): total_metrics[i] += metric(energy_scores, all_labels) n_samples = test_data_loader.n_samples print(f"Test loss: {total_loss / n_samples}") for i in range(len(metric_fn)): print( f"{metric_fn[i].__name__} : {total_metrics[i].item() / n_samples}")
def train(lr=args.lr, n_hidden=args.n_hidden, batch_size=args.batch_size, dropout=args.dropout, valid_freq=3000, disp_freq=1000, save_freq=100000, max_epochs=args.n_epoch, patience=15, save_name=args.save_name, save_dir=args.save_dir, device=args.device): # Load train and valid dataset print('loading train') with open(args.train_path, 'rb') as f: train_val_y = pickle.load(f) train_val_x = pickle.load(f) print('loading english test') with open(args.en_test_path, 'rb') as f: en_test_y = pickle.load(f) en_test_x = pickle.load(f) print('loading french test') with open(args.fr_test_path, 'rb') as f: fr_test_y = pickle.load(f) fr_test_x = pickle.load(f) sss = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=1125) for train_index, test_index in sss.split(train_val_x, train_val_y): train_y = train_val_y[train_index] train_x = train_val_x[train_index] valid_y = train_val_y[test_index] valid_x = train_val_x[test_index] print('Number of training sample: %d' % train_x.shape[0]) print('Number of validation sample: %d' % valid_x.shape[0]) print('Number of english testing sample: %d' % en_test_x.shape[0]) print('Number of french testing sample: %d' % fr_test_x.shape[0]) print('-' * 100) kf_valid = get_minibatches_idx(len(valid_y), batch_size) kf_en_test = get_minibatches_idx(len(en_test_y), batch_size) kf_fr_test = get_minibatches_idx(len(fr_test_y), batch_size) # Loader parameter: use CUDA pinned memory for faster data loading pin_memory = (device == args.device) # Test set n_emb = train_x.shape[1] n_class = len(set(train_y)) best_valid_acc = None bad_counter = 0 uidx = 0 # the number of update done estop = False # early stop switch net = MLP(n_mlp_layer=args.n_mlp_layers, n_hidden=args.n_hidden, dropout=args.dropout, n_class=n_class, n_emb=n_emb, device=args.device) if args.load_net != '': assert os.path.exists( args.load_net), 'Path to pretrained net does not exist' net.load_state_dict(torch.load(args.load_net)) print('Load exists model stored at: ', args.load_net) if args.device == 'gpu': net = net.cuda() # Begin Training net.train() print('-' * 100) print('Model structure: ') print('MLP baseline') print(net.main) print('-' * 100) print('Parameters for tuning: ') print(net.state_dict().keys()) print('-' * 100) # Define optimizer assert args.optimizer in [ 'SGD', 'Adam', "RMSprop", "LBFGS", "Rprop", "ASGD", "Adadelta", "Adagrad", "Adamax" ], 'Please choose either SGD or Adam' if args.optimizer == 'SGD': optimizer = optim.SGD(lr=lr, params=filter(lambda p: p.requires_grad, net.parameters()), momentum=0.9) else: optimizer = getattr(optim, args.optimizer)(params=filter( lambda p: p.requires_grad, net.parameters()), lr=lr) #lambda1 = lambda epoch: epoch // 30 lambda2 = lambda epoch: 0.98**epoch scheduler = optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=[lambda2]) #scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=max_epochs) #scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max') try: for eidx in range(max_epochs): scheduler.step() # print('Training mode on: ' ,net.training) start_time = time.time() n_samples = 0 # Get new shuffled index for the training set kf = get_minibatches_idx(len(train_y), batch_size, shuffle=True) for _, train_index in kf: # Remove gradient from previous batch #net.zero_grad() optimizer.zero_grad() uidx += 1 y_batch = torch.autograd.Variable( torch.from_numpy(train_y[train_index]).long()) x_batch = torch.autograd.Variable( torch.from_numpy(train_x[train_index]).float()) if net.device == 'gpu': y_batch = y_batch.cuda() scores = net.forward(x_batch) loss = net.loss(scores, y_batch) loss.backward() optimizer.step() n_samples += len(x_batch) gradient = 0 # For logging gradient information for name, w in net.named_parameters(): if w.grad is not None: w_grad = torch.norm(w.grad.data, 2)**2 gradient += w_grad gradient = gradient**0.5 if np.mod(uidx, disp_freq) == 0: print('Epoch ', eidx, 'Update ', uidx, 'Cost ', loss.data[0], 'Gradient ', gradient) if save_name and np.mod(uidx, save_freq) == 0: print('Saving...') torch.save( net.state_dict(), '%s/%s_epoch%d_update%d.net' % (save_dir, save_name, eidx, uidx)) if np.mod(uidx, valid_freq) == 0: print("=" * 50) print('Evaluation on validation set: ') kf_valid = get_minibatches_idx(len(valid_y), batch_size) top_1_acc, top_n_acc = eval.net_evaluation( net, kf_valid, valid_x, valid_y) #scheduler.step(top_1_acc) # Save best performance state_dict for testing if best_valid_acc is None: best_valid_acc = top_1_acc best_state_dict = net.state_dict() torch.save(best_state_dict, '%s/%s_best.net' % (save_dir, save_name)) else: if top_1_acc > best_valid_acc: print( 'Best validation performance so far, saving model parameters' ) print("*" * 50) bad_counter = 0 # reset counter best_valid_acc = top_1_acc best_state_dict = net.state_dict() torch.save( best_state_dict, '%s/%s_best.net' % (save_dir, save_name)) else: bad_counter += 1 print('Validation accuracy: ', 100 * top_1_acc) print('Getting worse, patience left: ', patience - bad_counter) print('Best validation accuracy now: ', 100 * best_valid_acc) # Learning rate annealing lr /= args.lr_anneal print('Learning rate annealed to: ', lr) print('*' * 100) if args.optimizer == 'SGD': optimizer = optim.SGD( lr=lr, params=filter(lambda p: p.requires_grad, net.parameters()), momentum=0.9) else: optimizer = getattr(optim, args.optimizer)( params=filter(lambda p: p.requires_grad, net.parameters()), lr=lr) if bad_counter > patience: print('-' * 100) print('Early Stop!') estop = True break epoch_time = time.time() - start_time print('Epoch processing time: %.2f s' % epoch_time) print('Seen %d samples' % n_samples) if estop: break print('-' * 100) print('Training finish') best_state_dict = torch.load('%s/%s_best.net' % (save_dir, save_name)) torch.save(net.state_dict(), '%s/%s_final.net' % (save_dir, save_name)) net.load_state_dict(best_state_dict) # add self connection print('Evaluation on validation set: ') kf_valid = get_minibatches_idx(len(valid_y), batch_size) eval.net_evaluation(net, kf_valid, valid_x, valid_y) # Evaluate model on test set print('Evaluation on test set: ') print('Evaluation on English testset: ') eval.net_evaluation(net, kf_en_test, en_test_x, en_test_y) print('Evaluation on French testset: ') eval.net_evaluation(net, kf_fr_test, fr_test_x, fr_test_y) except KeyboardInterrupt: print('-' * 100) print("Training interrupted, saving final model...") best_state_dict = torch.load('%s/%s_best.net' % (save_dir, save_name)) torch.save(net.state_dict(), '%s/%s_final.net' % (save_dir, save_name)) net.load_state_dict(best_state_dict) print('Evaluation on validation set: ') kf_valid = get_minibatches_idx(len(valid_y), batch_size) eval.net_evaluation(net, kf_valid, valid_x, valid_y) # Evaluate model on test set print('Evaluation on English testset: ') eval.net_evaluation(net, kf_en_test, en_test_x, en_test_y) print('Evaluation on French testset: ') eval.net_evaluation(net, kf_fr_test, fr_test_x, fr_test_y)
input_dim = 40*(2*k+1) output_dim = 138 print('Loading Inference Data...') val_data, val_idx = utils.load_data(os.path.join(args.data_path, 'test.npy'), k) val_label = np.arange(val_idx[-1]+len(val_data[val_idx[-1]])) val_dataset = utils.SpeechDataset(val_data,val_label,val_idx,k) val_dataloader = DataLoader( val_dataset, batch_size=batch_size, shuffle=False ) print('Data Loaded!') #Load Model model = MLP(input_dim, output_dim) model.to(device) model.load_state_dict(torch.load(args.model_file)) model.eval() print('Inference begins: ') pred_result = Val( val_dataloader, model ) datafile = pd.DataFrame({'id': pred_result[:,0], 'label': pred_result[:,1]}, index=None) datafile.to_csv('result.csv', index=False)
def test(n, run_number): df_4_40 = pd.read_csv('./test_{}/merged_config_test_4_40.csv'.format(run_number)) df_4_60 = pd.read_csv('./test_{}/merged_config_test_4_60.csv'.format(run_number)) df_4_80 = pd.read_csv('./test_{}/merged_config_test_4_80.csv'.format(run_number)) df_4_100 = pd.read_csv('./test_{}/merged_config_test_4_100.csv'.format(run_number)) df_8_40 = pd.read_csv('./test_{}/merged_config_test_8_40.csv'.format(run_number)) df_8_60 = pd.read_csv('./test_{}/merged_config_test_8_60.csv'.format(run_number)) df_8_80 = pd.read_csv('./test_{}/merged_config_test_8_80.csv'.format(run_number)) df_8_100 = pd.read_csv('./test_{}/merged_config_test_8_100.csv'.format(run_number)) best_config = pd.read_csv('./test_{}/best_config_file.csv'.format(run_number)) df_keys = {0: df_4_40, 1: df_4_60, 2: df_4_80, 3: df_4_100, 4: df_8_40, 5: df_8_60, 6: df_8_80, 7: df_8_100} min_rows = 0 min_rows = get_min_rows(df_keys, min_rows) if n == 1: model = MLP(15, 16, 8) else: model = MLP(7, 16, 8) model.load_state_dict(torch.load('checkpoint/MLP_model_19_train.pwf', map_location='cpu')) model.eval() data_point = list(df_8_100.iloc[0, [1, 2, 3, 5, 6, 7, 8]].values) if n == 1: one_hot_y = [0, 0, 0, 0, 0, 0, 0, 0] data_point = torch.Tensor(data_point + one_hot_y) else: data_point = torch.Tensor(data_point) with open("parameters.txt", "w") as f: f.write("Parameters \n") for i, param in enumerate(list(model.parameters())): if i % 2 == 0: weight = "weight for {} layer: ".format(i / 2 + 1) + str(param) + "\n" f.write(weight) else: bias = "bias for {} layer: ".format(int(i / 2) + 1) + str(param) + "\n" f.write(bias) cycles = df_8_100.iloc[0, 4] cycles_complete = df_8_100.iloc[0, 4] best_cycles = df_keys[best_config.iloc[0, -1]].iloc[0, 4] predicted = model.forward(data_point.reshape(1, -1)) predicted = np.argmax(predicted.detach().cpu().numpy(), axis=-1) cycles_array = [int(cycles)] cores = [8] llc = [100] x_pos = [0] for i in range(1, min_rows): data_point = list(df_keys[predicted[0]].iloc[i, [1, 2, 3, 5, 6, 7, 8]].values) if n == 1: one_hot_y = oneHotEncoding(predicted)[0] data_point = torch.Tensor(data_point + one_hot_y) else: data_point = torch.Tensor(data_point) x_pos.append(cycles) cycles_array.append(int(df_keys[predicted[0]].iloc[i, 4])) cores.append(cores_llc_dict[predicted[0]]['cores']) llc.append(cores_llc_dict[predicted[0]]['llc']) cycles = cycles + df_keys[predicted[0]].iloc[i, 4] predicted = model.forward(data_point.reshape(1, -1)) predicted = np.argmax(predicted.detach().cpu().numpy(), axis=-1) cycles_complete = cycles_complete + df_8_100.iloc[i, 4] best_cycles = best_cycles + df_keys[best_config.iloc[i, -1]].iloc[i, 4] print('About to plot the graphs for run_number: {}'.format(run_number)) font = {'family': 'serif', 'color': 'darkred', 'weight': 'normal', 'size': 32, } widths = [cycle * 10**-8*0.8 for cycle in cycles_array] x_pos_reduced = [x * 10**-8 for x in x_pos] plot_test_results(cores, font, run_number, widths, x_pos_reduced, 'Cores') plot_test_results(llc, font, run_number, widths, x_pos_reduced, 'LLC') print('run number:', run_number) print('cycles calculated:', cycles) print('cycles for complete configuration:', cycles_complete) print('best configuration cycles:', best_cycles) print('complete cycle percentage', cycles/cycles_complete * 100) print('best cycle percentage', cycles/best_cycles*100) print('\n')
############################# #####Random Ovesampling###### ############################# model = MLP() model = model.to(device) for name, param in model.named_parameters(): if param.device.type != 'cuda': print('param {}, not on GPU'.format(name)) wandb.init(project='Seq Boost2', config=config, name='RUS p={} mu={} eta={}'.format(P, M, E)) optimizer = optim.SGD(model.parameters(), lr=config['learning_rate'], momentum=config['momentum']) mid_model, train_loss, valid_loss = train(model, rus_train_loader, valid_loader, batch_size=BATCH_SIZE, wandb_log=True, patience=EARLY_STOPPING, consolidate=False, n_epochs=config['epoch']) model.load_state_dict(torch.load(os.path.join(PATH, 'checkpoint.pt'))) evaluate(model, test_loader, batch_size=BATCH_SIZE)