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
}
