)
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))