def _train(self): self.timestep+=1 #Select learning rate depending on the epoch. if self.timestep<50: l_r=0.0005 elif self.timestep<95: l_r=0.00015 else: l_r=0.00005 optimizer = torch.optim.Adam(self.mod.parameters(), lr=l_r, weight_decay=self.config["L2"]) criterion=nn.BCELoss() for i_batch,sampled_batch in enumerate(self.dataloader): optimizer.zero_grad() target=sampled_batch[2].to(self.device) pred=self.mod.forward(torch.transpose(sampled_batch[1].to(self.device),1,2),sampled_batch[3].to(self.device)) #Feed as batchxtimexfeatures loss=criterion(pred,target) loss.backward() optimizer.step() with torch.no_grad(): loss_val=0 #for i_val,batch_val in enumerate(self.dataloader_val): target=get_pinned_object(data_val).tags.to(self.device) pred=self.mod.forward(torch.transpose(get_pinned_object(data_val).data_matrix.to(self.device),1,2),get_pinned_object(data_val).cov_u.to(self.device)) #Feed as batchxtimexfeatures loss_val=roc_auc_score(target,pred) auc_mean=loss_val return TrainingResult(mean_accuracy=auc_mean,timesteps_this_iter=1)
def _train(self): func = _mode_func(self._alg) splits = get_pinned_object(self._id_splits) category_names = get_pinned_object(self._id_category_names) scores = [] for subject, samples in splits.items(): score = [] for X_train, y_train, X_test, y_test in samples: s = func(X_train=X_train.copy(), y_train=y_train.copy(), X_test=X_test.copy(), y_test=y_test.copy(), n_thread=1, category_names=deepcopy(category_names), params=self._params) score.append(s) scores.append(EvalScore.average(score)) avg_score = {} for score in scores: for k, v in score.items(): if k in avg_score: avg_score[k].append(v) else: avg_score[k] = [v] avg_score = {k: np.mean(v) for k, v in avg_score.items()} return dict(**avg_score, done=True)
def _setup(self): self.device=torch.device("cuda:0") #means_vec for imputation. self.mod=GRU_mean(get_pinned_object(data_train).meas_num,get_pinned_object(means_vec),self.device,get_pinned_object(data_train).cov_u.size(1),imputation_mode="simple") self.mod.float() self.mod.to(self.device) self.dataloader=DataLoader(get_pinned_object(data_train),batch_size=5000,shuffle=True,num_workers=2) #self.dataloader_val= DataLoader(get_pinned_object(data_val),batch_size=1000,shuffle=False) self.timestep=0
def _reset_model_args(self): model_args = self.config['model_args'].copy() model_args['weight_decay'] = self.config['weight_decay'] model_args['learning_rate'] = self.config['learning_rate'] model_args['max_seq_length'] = int(self.config['max_seq_length']) model_args['adam_epsilon'] = self.config['adam_epsilon'] model_args['warmup_ratio'] = self.config['warmup_ratio'] self.model_args = model_args self.eval_df = get_pinned_object(self.config['eval_df_id']) self.train_df = get_pinned_object(self.config['train_df_id']) self.class_weights = self.config['class_weights']
def _setup(self): self.device = torch.device("cuda:0") #means_vec for imputation. self.mod = GRU_teach(self.device, get_pinned_object(data_train).cov_u.size(1), get_pinned_object(data_train).data_matrix.size(1)) self.mod.float() self.mod.to(self.device) self.dataloader = DataLoader(get_pinned_object(data_train), batch_size=5000, shuffle=True, num_workers=2) self.timestep = 0
def _setup(self): self.device = torch.device("cuda:0") mod_opt = {'type': "plain_fact", 'cov': False, 'latents': 20} #data_train=TensorFactDataset(csv_file_serie="complete_tensor_train1.csv",cov_path="complete_covariates") self.mod = GRU_mean(get_pinned_object(data_train).get_dim()) self.dataloader = DataLoader(get_pinned_object(data_train), batch_size=5000, shuffle=True, num_workers=2) self.dataloader_val = DataLoader(get_pinned_object(data_val), batch_size=1000, shuffle=False) #self.dataloader=DataLoader(data_train,batch_size=65000,shuffle=True,num_workers=2) self.timestep = 0 print("SETUUUUP")
def _setup(self, config): torch.backends.cudnn.deterministic = True self.cuda_available = torch.cuda.is_available() self.args = get_pinned_object(pinned_obj_dict['args']) seed = self.args.seed np.random.seed(seed) torch.manual_seed(seed) if self.cuda_available: torch.cuda.manual_seed(seed) self.data_loader_train = get_pinned_object( pinned_obj_dict['data_loader_train']) self.data_loader_valid = get_pinned_object( pinned_obj_dict['data_loader_valid']) print("Cuda is available: {}".format(self.cuda_available)) self.model = get_model() if self.cuda_available: self.model.cuda() opt = getattr(torch.optim, self.config['optimizer']) self.optimizer = opt(self.model.parameters(), lr=self.config['lr']) self.batch_accumulation = self.config['batch_accumulation']
def _setup(self): self.sen = model.SpeakerEmbedding2d(self.config["nspeakers"]) self.siamese_sen = model.SiameseNet(self.sen) self.optimizer = optim.SGD(params=self.sen.parameters(), lr=self.config["lr"], weight_decay=0.0001) self.iteration = 1 td = self.config['train_set_id'] self.train_set = get_pinned_object(td) print("Loaded train") dd = self.config['dev_set_id'] self.dev_enrol_set, self.dev_test_set, self.dev_trials, self.dev_labels = get_pinned_object( dd) print("Loaded dev") self.lr_scheduler = torch.optim.lr_scheduler.MultiStepLR( self.optimizer, milestones=[20, 30, 40, 50, 60, 80, 100, 120], gamma=0.5) cuda = torch.cuda.is_available() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") if cuda: self.sen.to(device)
def _setup(self): self.device = torch.device("cuda:0") mod_opt = {'type': "plain_fact", 'cov': False, 'latents': 20} self.nfolds = self.config["nfolds"] #data_train=TensorFactDataset(csv_file_serie="complete_tensor_train1.csv",cov_path="complete_covariates") self.mod = [] self.dataloader = [] self.data_val = get_pinned_object(data_val) for fold in range(self.nfolds): mod_fold = MLP_class_mod( get_pinned_object(data_train)[fold].get_dim()) mod_fold.to(self.device) self.mod += [mod_fold] #self.mod=MLP_class_mod(get_pinned_object(data_train).get_dim()) self.dataloader += [ DataLoader(get_pinned_object(data_train)[fold], batch_size=5000, shuffle=True) ] #self.dataloader_val += DataLoader(get_pinned_object(data_val),batch_size=1000,shuffle=False) #self.dataloader=DataLoader(data_train,batch_size=65000,shuffle=True,num_workers=2) self.timestep = 0 print("SETUUUUP")
def compute_set( N, alpha, iterations, resolution, extent, #zi, seed=None zi_obj, seed=None): np.warnings.filterwarnings('ignore') np.random.seed(seed) zi = get_pinned_object(zi_obj) pts = get_iterations(N, alpha, iterations, zi) counts = pts_to_bins(pts, resolution, extent) #print(f"Found {counts.sum()/10**6:0.1f}*10**6 points") return counts
def _train(self): self.timestep+=1 n_splits=2 skf = StratifiedKFold(n_splits=n_splits,random_state=7) auc=0 for train_index, val_index in skf.split(get_pinned_object(x),get_pinned_object(y)): x_train=get_pinned_object(x)[train_index,:] y_train=get_pinned_object(y)[train_index] x_val=get_pinned_object(x)[val_index,:] y_val=get_pinned_object(y)[val_index] probas_=self.clf.fit(x_train,y_train).predict_proba(x_val) print(y_val.shape) print(probas_.shape) auc+=roc_auc_score(y_val,probas_[:,1]) return TrainingResult(mean_accuracy=auc/n_splits,timesteps_this_iter=1)
def train_func(config, reporter): # add a reporter arg my_lr = config["lr"] cur_data = get_pinned_object(data) with tf.Session() as sess: x, y_, keep_prob, train_step, accuracy = build_model(my_lr) print('number of global vars:', len(tf.global_variables())) sess.run(tf.global_variables_initializer()) for i in range(2000): batch = cur_data.get_next_train(50) if i % 100 == 0: train_accuracy = accuracy.eval(feed_dict={ x: batch[0], y_: batch[1], keep_prob: 1.0 }) print('step %d, learning rate %f training accuracy %g' % (i, my_lr, train_accuracy)) reporter(timesteps_total=i, mean_accuracy=train_accuracy) train_step.run(feed_dict={ x: batch[0], y_: batch[1], keep_prob: 0.5 })
def train(config, reporter): get_pinned_object(X) reporter(timesteps_total=100, done=True)
def f(): return get_pinned_object(X)
def _train(self): self.timestep += 1 #Select learning rate depending on the epoch. if self.timestep < 50: l_r = 0.0005 elif self.timestep < 100: l_r = 0.00015 elif self.timestep < 150: l_r = 0.00005 else: l_r = 0.00001 optimizer = torch.optim.Adam(self.mod.parameters(), lr=l_r, weight_decay=self.config["L2"]) criterion = nn.MSELoss(reduce=False, size_average=False) class_criterion = nn.BCEWithLogitsLoss() for i_batch, sampled_batch in enumerate(self.dataloader): optimizer.zero_grad() [preds, class_preds] = self.mod.forward(sampled_batch[2].to(self.device), sampled_batch[0].to(self.device), sampled_batch[1].to(self.device)) targets = sampled_batch[0].to(self.device) targets.masked_fill_(1 - sampled_batch[1].to(self.device), 0) preds.masked_fill_(1 - sampled_batch[1].to(self.device), 0) loss = (1 - self.config["mixing_ratio"]) * ( torch.sum(criterion(preds, targets)) / torch.sum(sampled_batch[1].to(self.device)).float() ) + self.config["mixing_ratio"] * class_criterion( class_preds, sampled_batch[3].to(self.device)) loss.backward() optimizer.step() with torch.no_grad(): [preds, class_preds] = self.mod.forward( get_pinned_object(data_val).cov_u.to(self.device), get_pinned_object(data_val).data_matrix.to(self.device), get_pinned_object(data_val).observed_mask.to(self.device)) targets = get_pinned_object(data_val).data_matrix.to(self.device) targets.masked_fill_( 1 - get_pinned_object(data_val).observed_mask.to(self.device), 0) preds.masked_fill_( 1 - get_pinned_object(data_val).observed_mask.to(self.device), 0) #loss_val=class_criterion(class_preds,get_pinned_object(data_val).tags.to(self.device)).cpu().detach().numpy() loss_val = roc_auc_score( get_pinned_object(data_val).tags, class_preds.cpu()) print("Validation Loss") print(loss_val) [preds, class_preds] = self.mod.forward( get_pinned_object(data_test).cov_u.to(self.device), get_pinned_object(data_test).data_matrix.to(self.device), get_pinned_object(data_test).observed_mask.to(self.device)) targets = get_pinned_object(data_test).data_matrix.to(self.device) targets.masked_fill_( 1 - get_pinned_object(data_test).observed_mask.to(self.device), 0) preds.masked_fill_( 1 - get_pinned_object(data_test).observed_mask.to(self.device), 0) #loss_val=class_criterion(class_preds,get_pinned_object(data_val).tags.to(self.device)).cpu().detach().numpy() loss_test = roc_auc_score( get_pinned_object(data_test).tags, class_preds.cpu()) return { 'mean_accuracy': loss_val, 'timesteps_this_iter': 1, 'test_auc': loss_test }