) noisy_loader = DataLoader( dataset_noisy, batch_size=BATCH_SIZE, shuffle=True, num_workers=1, pin_memory=True, ) noisy_itr = cycle(noisy_loader) # set optimizer and loss optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=LR[0]) scheduler = CosineLR(optimizer, step_size_min=LR[1], t0=len(train_loader) * NUM_CYCLE, tmult=1) # training min_val_lwlrap = 0 trigger = 0 for epoch in range(NUM_EPOCH): # train for one epoch bce, lwlrap, bce_noisy, lwlrap_noisy = train( (train_loader, noisy_itr), model, optimizer, scheduler, epoch) # evaluate on validation set val_bce, val_lwlrap = validate(valid_loader, model) # print log endtime = time.time() - starttime
def main(): # load table data df_train = pd.read_csv("../input/train_curated.csv") df_noisy = pd.read_csv("../input/train_noisy.csv") df_test = pd.read_csv("../input/sample_submission.csv") labels = df_test.columns[1:].tolist() for label in labels: df_train[label] = df_train['labels'].apply(lambda x: label in x) df_noisy[label] = df_noisy['labels'].apply(lambda x: label in x) df_train['path'] = "../input/mel128/train/" + df_train['fname'] df_test['path'] = "../input/mel128/test/" + df_train['fname'] df_noisy['path'] = "../input/mel128/noisy/" + df_noisy['fname'] # fold splitting folds = list(KFold(n_splits=NUM_FOLD, shuffle=True, random_state=SEED).split(np.arange(len(df_train)))) # Training log_columns = ['epoch', 'bce', 'lwlrap', 'bce_noisy', 'lwlrap_noisy', 'val_bce', 'val_lwlrap', 'time'] for fold, (ids_train_split, ids_valid_split) in enumerate(folds): if fold+1 not in FOLD_LIST: continue print("fold: {}".format(fold + 1)) train_log = pd.DataFrame(columns=log_columns) # build model model = ResNet(NUM_CLASS).cuda() # prepare data loaders df_train_fold = df_train.iloc[ids_train_split].reset_index(drop=True) dataset_train = MelDataset(df_train_fold['path'], df_train_fold[labels].values, crop=CROP_LENGTH, crop_mode='random', mixup=True, freqmask=True, gain=True, ) train_loader = DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True, num_workers=1, pin_memory=True, ) df_valid = df_train.iloc[ids_valid_split].reset_index(drop=True) dataset_valid = MelDataset(df_valid['path'], df_valid[labels].values,) valid_loader = DataLoader(dataset_valid, batch_size=1, shuffle=False, num_workers=1, pin_memory=True, ) dataset_noisy = MelDataset(df_noisy['path'], df_noisy[labels].values, crop=CROP_LENGTH, crop_mode='random', mixup=True, freqmask=True, gain=True, ) noisy_loader = DataLoader(dataset_noisy, batch_size=BATCH_SIZE, shuffle=True, num_workers=1, pin_memory=True, ) noisy_itr = cycle(noisy_loader) # set optimizer and loss optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=LR[0]) scheduler = CosineLR(optimizer, step_size_min=LR[1], t0=len(train_loader) * NUM_CYCLE, tmult=1) # training for epoch in range(NUM_EPOCH): # train for one epoch bce, lwlrap, bce_noisy, lwlrap_noisy = train((train_loader, noisy_itr), model, optimizer, scheduler, epoch) # evaluate on validation set val_bce, val_lwlrap = validate(valid_loader, model) # print log endtime = time.time() - starttime print("Epoch: {}/{} ".format(epoch + 1, NUM_EPOCH) + "CE: {:.4f} ".format(bce) + "LwLRAP: {:.4f} ".format(lwlrap) + "Noisy CE: {:.4f} ".format(bce_noisy) + "Noisy LWLRAP: {:.4f} ".format(lwlrap_noisy) + "Valid CE: {:.4f} ".format(val_bce) + "Valid LWLRAP: {:.4f} ".format(val_lwlrap) + "sec: {:.1f}".format(endtime) ) # save log and weights train_log_epoch = pd.DataFrame( [[epoch+1, bce, lwlrap, bce_noisy, lwlrap_noisy, val_bce, val_lwlrap, endtime]], columns=log_columns) train_log = pd.concat([train_log, train_log_epoch]) train_log.to_csv("{}/train_log_fold{}.csv".format(OUTPUT_DIR, fold+1), index=False) if (epoch+1)%NUM_CYCLE==0: torch.save(model.state_dict(), "{}/weight_fold_{}_epoch_{}.pth".format(OUTPUT_DIR, fold+1, epoch+1))
def main(): # load table data df_train = pd.read_csv("../input/train_curated.csv") df_noisy = pd.read_csv("../input/train_noisy.csv") df_test = pd.read_csv("../input/sample_submission.csv") labels = df_test.columns[1:].tolist() for label in labels: df_train[label] = df_train['labels'].apply(lambda x: label in x) df_noisy[label] = df_noisy['labels'].apply(lambda x: label in x) df_train['path'] = "../input/mel128/train/" + df_train['fname'] df_test['path'] = "../input/mel128/test/" + df_train['fname'] df_noisy['path'] = "../input/mel128/noisy/" + df_noisy['fname'] # calc sampling weight df_train['weight'] = 1 df_noisy['weight'] = len(df_train) / len(df_noisy) # generate pseudo label with sharpening tmp = np.load("../input/pseudo_label/preds_noisy.npy").mean(axis=(0, 1)) tmp = tmp**TEMPERATURE tmp = tmp / tmp.sum(axis=1)[:, np.newaxis] df_noisy_pseudo = df_noisy.copy() df_noisy_pseudo[labels] = tmp # fold splitting folds = list( KFold(n_splits=NUM_FOLD, shuffle=True, random_state=SEED).split(np.arange(len(df_train)))) folds_noisy = list( KFold(n_splits=NUM_FOLD, shuffle=True, random_state=SEED).split(np.arange(len(df_noisy)))) # Training log_columns = [ 'epoch', 'bce', 'lwlrap', 'bce_noisy', 'lwlrap_noisy', 'semi_mse', 'val_bce', 'val_lwlrap', 'time' ] for fold, (ids_train_split, ids_valid_split) in enumerate(folds): if fold + 1 not in FOLD_LIST: continue print("fold: {}".format(fold + 1)) train_log = pd.DataFrame(columns=log_columns) # build model model = ResNet(NUM_CLASS).cuda() model.load_state_dict( torch.load("{}/weight_fold_{}_epoch_512.pth".format( LOAD_DIR, fold + 1))) # prepare data loaders df_train_fold = df_train.iloc[ids_train_split].reset_index(drop=True) dataset_train = MelDataset( df_train_fold['path'], df_train_fold[labels].values, crop=CROP_LENGTH, crop_mode='additional', crop_rate=CROP_RATE, mixup=True, freqmask=True, gain=True, ) train_loader = DataLoader( dataset_train, batch_size=BATCH_SIZE, shuffle=True, num_workers=1, pin_memory=True, ) df_valid = df_train.iloc[ids_valid_split].reset_index(drop=True) dataset_valid = MelDataset( df_valid['path'], df_valid[labels].values, ) valid_loader = DataLoader( dataset_valid, batch_size=1, shuffle=False, num_workers=1, pin_memory=True, ) dataset_noisy = MelDataset( df_noisy['path'], df_noisy[labels].values, crop=CROP_LENGTH, crop_mode='additional', crop_rate=CROP_RATE, mixup=True, freqmask=True, gain=True, ) noisy_loader = DataLoader( dataset_noisy, batch_size=BATCH_SIZE, shuffle=True, num_workers=1, pin_memory=True, ) noisy_itr = cycle(noisy_loader) df_semi = pd.concat([ df_train.iloc[ids_train_split], df_noisy_pseudo.iloc[folds_noisy[fold][0]] ]).reset_index(drop=True) semi_sampler = torch.utils.data.sampler.WeightedRandomSampler( df_semi['weight'].values, len(df_semi)) dataset_semi = MelDataset( df_semi['path'], df_semi[labels].values, crop=CROP_LENGTH, crop_mode='additional', crop_rate=CROP_RATE, mixup=True, freqmask=True, gain=True, ) semi_loader = DataLoader( dataset_semi, batch_size=BATCH_SIZE, shuffle=False, num_workers=1, pin_memory=True, sampler=semi_sampler, ) semi_itr = cycle(semi_loader) # set optimizer and loss optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=LR[0]) scheduler = CosineLR(optimizer, step_size_min=LR[1], t0=len(train_loader) * NUM_CYCLE, tmult=1) # training for epoch in range(NUM_EPOCH): # train for one epoch bce, lwlrap, bce_noisy, lwlrap_noisy, mse_semi = train( (train_loader, noisy_itr, semi_itr), model, optimizer, scheduler, epoch) # evaluate on validation set val_bce, val_lwlrap = validate(valid_loader, model) # print log endtime = time.time() - starttime print("Epoch: {}/{} ".format(epoch + 1, NUM_EPOCH) + "CE: {:.4f} ".format(bce) + "LwLRAP: {:.4f} ".format(lwlrap) + "Noisy CE: {:.4f} ".format(bce_noisy) + "Noisy LWLRAP: {:.4f} ".format(lwlrap_noisy) + "Semi MSE: {:.4f} ".format(mse_semi) + "Valid CE: {:.4f} ".format(val_bce) + "Valid LWLRAP: {:.4f} ".format(val_lwlrap) + "sec: {:.1f}".format(endtime)) # save log and weights train_log_epoch = pd.DataFrame([[ epoch + 1, bce, lwlrap, bce_noisy, lwlrap_noisy, mse_semi, val_bce, val_lwlrap, endtime ]], columns=log_columns) train_log = pd.concat([train_log, train_log_epoch]) train_log.to_csv("{}/train_log_fold{}.csv".format( OUTPUT_DIR, fold + 1), index=False) if (epoch + 1) % NUM_CYCLE == 0: torch.save( model.state_dict(), "{}/weight_fold_{}_epoch_{}.pth".format( OUTPUT_DIR, fold + 1, epoch + 1))