global check_point_flag, check_point_D, num_epoch, best_accuracy, mass_error, gap

# Read the mgf file to obtain the spectra.

s = SpectrumRead(mgf_file_path)

spectra_list = s.read_spectrum_data()

print("Read the mgf file successfully!")

# Fileter the unlabel spectra.

spectra_list = spectrum_refine(spectra_list, spectrum_results_file_path)

# generate the tag candidats with defeated parameters.

print("The program is extracting the tag sequence conditioned on each spectrum: ")

t = Generator(spectra_list, mass_error)

t.process_spectrum_list()

print("The extracted tag sequences are saved!")

# save the tag candidates features.

t.save_tag_feature(data_folder)

# Label the generated tags.

tag_correct_discriminate(data_folder, spectrum_results_file_path)

# Initialize model or load checkpoint

if check_point_flag is False:

discriminator = Discriminator()

else:

check_point_D = torch.load(check_point_D)

discriminator = check_point_D['model']

# Move to GPU, if available.

discriminator = discriminator.to(device)

# model parameters optimization with classical SGD.

optimizer = torch.optim.SGD(discriminator.parameters(), lr=lr)

# Loss function.

criterion = nn.CrossEntropyLoss().to(device)

# criterion = ImprovedLoss().to(device)

# training and evaluation dataloaders.

train_loader = DataLoader(SpectrumLoader(train_tag_feature_path, train_tag_label_path),

batch_size=batch_size, shuffle=True, num_workers=works)

val_loader = DataLoader(SpectrumLoader(val_tag_feature_path, val_tag_label_path),

batch_size=batch_size, shuffle=True, num_workers=works)

print('The Tag Discriminator is ready to train.')

for epoch in range(num_epoch):

# One epoch's training

discriminator_train(train_loader=train_loader,

model=discriminator,

criterion=criterion,

optimizer=optimizer,

epoch=epoch)

# One epoch's validation

recent_accuracy = discriminator_val(val_loader=val_loader,

model=discriminator)

#

# print(recent_accuracy)

# check if was best and save the best checkpoint.

is_best = recent_accuracy > best_accuracy

if is_best:

filename = 'discriminator_check_point.pth.tar'

state = {'model': discriminator,

'accuracy': best_accuracy}

torch.save(state, filename)

# After initialize the generator and discriminator, we further incorporate the adversial learning to

# fine-tune the model for better performance.

# Usually 2 iterative steps is enough for performance metric convergence.

print('The Adversial Game is ready to play!')

for i in range(max_game_step):

# adjust the tag generator parameters conditioned on the trained discriminator.

mass_error = generator_adjust(mass_error, discriminator, spectra_list, val_loader)

# re-train the dicriminator and store the best model conditioned on current tag generator.

for epoch in range(num_epoch):

discriminator_train(train_loader=train_loader,

model=discriminator,

criterion=criterion,

optimizer=optimizer,

epoch=epoch)

recent_accuracy = discriminator_val(val_loader=val_loader,

model=discriminator)

is_best = recent_accuracy > best_accuracy

if is_best:

filename = 'discriminator_check_point.pth.tar'

state = {'model': discriminator,

'accuracy': best_accuracy}

torch.save(state, filename)

global gap, mass_error_reduction, best_accuracy, lamb

best_mass_error = mass_error

gap = mass_error_reduction * gap

mass_gap = gap * mass_error

best_reward = 0

# grid search under the dynamic parameter range.

for error in np.arange(mass_error-mass_gap, mass_error+mass_gap, 0.5*mass_gap):

# re-generate the candidate tag features.

t = Generator(spectra_list, error)

t.process_spectrum_list()

t.save_tag_feature(data_folder)

tag_correct_discriminate(data_folder, spectrum_results_file_path)

# calculate the accuracy and weighted reward for the tag generator.

current_accuracy = discriminator_val(val_loader, discriminator)

current_reward = lamb * current_accuracy + (1 - lamb) * (1 - current_accuracy)

# store the best model conditioned on current discriminator.

if current_reward > best_reward:

best_mass_error = error

# The pre-defined stopping criterion.

if abs(best_reward-current_reward) < 0.001:

break

model.train()

losses = AverageMeter()

for i, (tag_feature, tag_label) in enumerate(train_loader):

tag_feature = tag_feature.to(device)

# dimension adjusts for tag_label.

tag_label_1_d = [t[0] for t in tag_label]

tag_label_1_d = torch.LongTensor(tag_label_1_d)

tag_label = tag_label_1_d.to(device)

# Forward prop.

scores = model(tag_feature)

print(tag_label)

# calculate the loss.

loss = criterion(scores, tag_label)

# Back prop.

optimizer.zero_grad()

loss.backward()

# Update weights.

optimizer.step()

losses.update(loss.item())

# print the real-time loss.

if i % print_freq == 0:

print('Epoch: [{0}][{1}/{2}]\t'

'Loss {loss.val:.4f} ({loss.avg:.4f})'

model.eval()

accuracy = AverageMeter()

with torch.no_grad():

for i, (tag_feature, tag_label) in enumerate(val_loader):

tag_feature = tag_feature.to(device)

tag_label = tag_label.to(device)

scores = model(tag_feature)

# compare the prediction label and true label to compute the accuracy.

predict_idx = torch.max(scores, 1)[1]

idx = torch.max(tag_label, 1)[1]

assert idx.size(0) == predict_idx.size(0)

accuracy_tmp = sum(predict_idx == idx).item() / idx.size(0)

# We provide the real-time accuray and total accuracy to observe the training process.

accuracy.update(accuracy_tmp)