def main( model_dir: str, vc_src: str, vc_tgt: str, adv_tgt: str, output: str, eps: float, n_iters: int, attack_type: str, ): assert attack_type == "emb" or vc_src is not None model, config, attr, device = load_model(model_dir) vc_tgt = file2mel(vc_tgt, **config["preprocess"]) adv_tgt = file2mel(adv_tgt, **config["preprocess"]) vc_tgt = normalize(vc_tgt, attr) adv_tgt = normalize(adv_tgt, attr) vc_tgt = torch.from_numpy(vc_tgt).T.unsqueeze(0).to(device) adv_tgt = torch.from_numpy(adv_tgt).T.unsqueeze(0).to(device) if attack_type != "emb": vc_src = file2mel(vc_src, **config["preprocess"]) vc_src = normalize(vc_src, attr) vc_src = torch.from_numpy(vc_src).T.unsqueeze(0).to(device) if attack_type == "e2e": adv_inp = e2e_attack(model, vc_src, vc_tgt, adv_tgt, eps, n_iters) elif attack_type == "emb": adv_inp = emb_attack(model, vc_tgt, adv_tgt, eps, n_iters) elif attack_type == "fb": adv_inp = fb_attack(model, vc_src, vc_tgt, adv_tgt, eps, n_iters) else: raise NotImplementedError() adv_inp = adv_inp.squeeze(0).T adv_inp = denormalize(adv_inp.data.cpu().numpy(), attr) adv_inp = mel2wav(adv_inp, **config["preprocess"]) sf.write(output, adv_inp, config["preprocess"]["sample_rate"])
def infer(data_filepath='data/flowers.hdf5', z_dim=128, out_dir='gan', n_steps=10): G = load_model(out_dir) val_data = get_data(data_filepath, 'train') val_data = next(iterate_minibatches(val_data, 1)) emb_fixed, txt_fixed = val_data[1], val_data[2] z_start = np.random.uniform(-1, 1, size=(1, z_dim)) z_end = np.random.uniform(-1, 1, size=(1, z_dim)) G.trainable = False for i in range(n_steps + 1): p = i / float(n_steps) z = z_start * (1 - p) + z_end * p fake_image = G.predict([z, emb_fixed])[0] img = ((fake_image + 1) * 0.5) plt.imsave("{}/fake_z_interpolation_i{}".format(out_dir, i), img) print(i, str(txt_fixed[0]).strip(), file=open("{}/fake_z_interpolation.txt".format(out_dir), "a"))
training_cutoff=validation_cutoff, validation_cutoff=None) #%% Train and Save Models models = [] regions_val = list(set(df_validation[region_col])) dates_val = sorted(list(set(df_validation[date_col]))) validation_predictions = {} if train_bilstm: bilstm = BILSTMModel(**bilstm_params_dict) bilstm.fit(df_train, 'first') models.append('bilstm') save_model(bilstm, bilstm_file.replace(".pickle", "_train.pickle")) if load_bilstm: bilstm = load_model(bilstm_file.replace(".pickle", "_train.pickle")) validation_predictions['bilstm'] = bilstm.predict( regions_val, dates_val, 'first') models.append('bilstm') if train_sir: sir = SIRModel(**sir_params_dict) sir.fit(df_train) save_model(sir, sir_file.replace(".pickle", "_train.pickle")) if load_sir: sir = load_model(sir_file.replace(".pickle", "_train.pickle")) try: validation_predictions['sir'] = sir.predict(regions_val, dates_val) except: pass
warnings.filterwarnings('ignore') # %% df, df_train, df_test = load_data(training_cutoff=training_cutoff, validation_cutoff=validation_cutoff) regions = list(set(df_test[region_col])) dates = list(set(df_test[date_col])) # %% Load Models and Make Predictions output = {} models = [] if load_sir: sir = load_model(sir_file) output['sir'] = sir.predict(regions, dates) models.append('sir') if load_knn: knn = load_model(knn_file) output['knn'] = knn.predict(regions, dates) models.append('knn') if load_mdp: mdp = load_model(mdp_file) output['mdp'] = mdp.predict(regions, dates) models.append('mdp') if load_bilstm: bilstm = load_model(bilstm_file)
def train_flair(model_name=''): # Init data train_dataset, val_dataset = prepare_datasets_FLAIR() train_loader = DataLoader(train_dataset, batch_size=10, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=10, shuffle=True) loaders = dict(train=train_loader, val=val_loader) # Init Model if model_name == '': model = UNetFLAIR().cuda() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, amsgrad=True) scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer=optimizer, gamma=0.984) loss_fn = nn.BCELoss() else: model = data_utils.load_model(model_name) epochs = 500 epoch_losses = dict(train=[], val=[]) for epoch in range(epochs): for phase in 'train val'.split(): if phase == 'train': model = model.train() torch.set_grad_enabled(True) else: model = model.eval() torch.set_grad_enabled(False) loader = loaders[phase] running_loss = [] for batch in loader: imgs, masks = batch imgs = imgs.cuda() masks = masks.cuda() outputs = model(imgs) loss = loss_fn(outputs, masks) running_loss.append(loss.item()) if phase == 'train': optimizer.zero_grad() loss.backward() optimizer.step() # End of Epoch print(f'{epoch}) {phase} loss: {np.mean(running_loss)}') visualize_results(loader, model, epoch, phase) if epoch % 10 == 0: results_dir = 'weight_flair/' if not os.path.isdir(results_dir): os.makedirs(results_dir) data_utils.save_model(model, results_dir + f'model_{epoch}.pt') epoch_losses[phase].append(np.mean(running_loss)) if phase == 'val': df = pd.DataFrame(data=epoch_losses) df.to_csv('loss.csv') tensorboard(epoch_losses[phase], phase) if phase == 'train': scheduler.step()
def load_model(filename): assert os.path.exists('models/{}.pkl'.format(filename)) return d.load_model(filename)
training_cutoff=training_agg_cutoff, validation_cutoff=training_cutoff) # %% Train and Save Models models = [] regions_val = list(set(df_validation[region_col])) dates_val = list(set(df_validation[date_col])) validation_predictions = {} if train_sir: sir = SIRModel(**sir_params_dict) sir.fit(df_train) save_model(sir, sir_file) if load_sir: sir = load_model(sir_file) try: validation_predictions['sir'] = sir.predict(regions_val, dates_val) except: pass models.append('sir') if train_knn: knn = KNNModel(**knn_params_dict) knn.fit(df_train) models.append('knn') save_model(knn, knn_file) if load_knn: knn = load_model(knn_file) try: validation_predictions['knn'] = knn.predict(regions_val, dates_val)
def sample(self, t_0: str, n_samples: int, dates: list, input_samples: dict, validation_cutoff:str) -> dict: dir_path = os.path.dirname(os.path.abspath(__file__)) repo_path = os.path.join(dir_path, '..', '..', '..') np.random.seed(self.model_parameters['random_seed']) random_state = self.model_parameters['random_seed'] sir_file = pd.read_csv(os.path.join( repo_path, self.model_parameters['sir_file'])) knn_file = pd.read_csv(os.path.join( repo_path, self.model_parameters['knn_file'])) mdp_file = pd.read_csv(os.path.join( repo_path, self.model_parameters['mdp_file'])) bilstm_file = pd.read_csv(os.path.join( repo_path, self.model_parameters['bilstm_file'])) agg_file = pd.read_csv(os.path.join( repo_path, self.model_parameters['agg_file'])) ci_file = pd.read_csv(os.path.join( repo_path, self.model_parameters['ci_file'])) ci_file = pd.read_csv(os.path.join( repo_path, self.model_parameters['preval_file'])) regions = ['Massachusetts', 'New York'] output = {} if any([datetime.datetime.strptime(validation_cutoff, '%Y-%m-%d') <= date for date in dates]): raise Exception('Prediction dates appear in the training data. Please make predictions for a date after ' + validation_cutoff) sir = load_model(sir_file) output['sir'] = sir.predict(regions, dates) knn = load_model(knn_file) output['knn'] = knn.predict(regions, dates) mdp = load_model(mdp_file) output['mdp'] = mdp.predict(regions, dates) bilstm = load_model(bilstm_file) output['bilstm'] = bilstm.predict(regions, dates) agg = load_model(agg_file) output['agg'] = agg.predict(regions, dates, output) ci = load_model(ci_file) preval = load_model(preval_file) sampled_output = ci.sample(output, n_samples, random_state) model_type = 'agg' prediction_distribution = dict.fromkeys(regions) for state in regions: predictions = sampled_output[model_type][state] prediction_distribution[state] = predictions all_samples = [] date_list = sampled_output[model_type][regions[0]][0].index.strftime('%Y-%m-%d').tolist() samples = dict(dates=date_list, samples=None) for t_i in range(n_samples): sample_dict = dict.fromkeys(regions) for state in regions: sample_dict[state] = list(prediction_distribution[state][t_i]) all_samples.append(sample_dict) samples['samples'] = all_samples samples['samples'] = [[{state:samples['samples'][i][state][date] for state in samples['samples'][0].keys()} for date in range(len(samples['dates']))] for i in range(n_samples)] preval = load_model(preval_file) samples = preval.convert(samples) return samples