mcy98's picture
Upload folder using huggingface_hub
6077218 verified
Raw History Blame Contribute Delete
5.47 kB
import os
import torch
import numpy as np
from tqdm import tqdm
from torch.optim import AdamW
from base import AbstractModel
from transformers.optimization import get_scheduler
from collections import defaultdict, OrderedDict
from utils import get_file_name, get_total_steps
from evaluator import Evaluator
class BaseTrainer(object):
def __init__(self, config: dict, model: AbstractModel):
self.config = config
self.model = model
self.accelerator = config['accelerator']
self.evaluator = Evaluator(config)
self.saved_model_ckpt = os.path.join(
self.config['ckpt_dir'],
get_file_name(self.config, suffix='.pth')
)
os.makedirs(os.path.dirname(self.saved_model_ckpt), exist_ok=True)
self.best_metric = 0
self.best_epoch = 0
self.count = 0
self.checkpoints_deque = []
def train(self, train_dataloader, val_dataloader):
optimizer = AdamW(
self.model.parameters(),
lr=self.config['lr'],
weight_decay=self.config['weight_decay'],
)
total_n_steps = get_total_steps(self.config, train_dataloader)
self.model, optimizer, train_dataloader, val_dataloader = self.accelerator.prepare(
self.model, optimizer, train_dataloader, val_dataloader)
self.config.pop('accelerator')
self.accelerator.init_trackers(
project_name="PreferDiff",
config=self.config
)
n_epochs = np.ceil(total_n_steps / (len(train_dataloader) * self.accelerator.num_processes)).astype(int)
best_epoch = 0
best_val_score = -1
for epoch in range(n_epochs):
# Training
self.model.train()
total_loss = 0.0
train_progress_bar = tqdm(
train_dataloader,
total=len(train_dataloader),
desc=f"Training - [Epoch {epoch + 1}]",
)
for batch in train_progress_bar:
optimizer.zero_grad()
outputs = self.model(batch)
loss = outputs['loss']
self.accelerator.backward(loss)
optimizer.step()
# scheduler.step()
total_loss = total_loss + loss.item()
self.accelerator.log({"Loss/train_loss": total_loss / len(train_dataloader)}, step=epoch + 1)
# Evaluation
if (epoch + 1) % self.config['eval_interval'] == 0:
all_results = self.evaluate(val_dataloader, split='val')
if self.accelerator.is_main_process:
for key in all_results:
self.accelerator.log({f"Val_Metric/{key}": all_results[key]}, step=epoch + 1)
print(all_results)
val_score = all_results[self.config['val_metric']]
if val_score > best_val_score:
best_val_score = val_score
best_epoch = epoch + 1
if self.accelerator.is_main_process:
if self.config['use_ddp']: # unwrap model for saving
unwrapped_model = self.accelerator.unwrap_model(self.model)
torch.save(unwrapped_model.state_dict(), self.saved_model_ckpt)
else:
torch.save(self.model.state_dict(), self.saved_model_ckpt)
print(f'[Epoch {epoch + 1}] Saved model checkpoint to {self.saved_model_ckpt}')
else:
print('Patience for {} Times'.format(epoch + 1 - best_epoch))
if self.config['patience'] is not None and epoch + 1 - best_epoch >= self.config['patience']:
print(f'Early stopping at epoch {epoch + 1}')
break
print(f'Best epoch: {best_epoch}, Best val score: {best_val_score}')
def evaluate(self, dataloader, split='test'):
self.model.eval()
all_results = defaultdict(list)
val_progress_bar = tqdm(
dataloader,
total=len(dataloader),
desc=f"Eval - {split}",
)
for batch in val_progress_bar:
with torch.no_grad():
batch = {k: v.to(self.accelerator.device) for k, v in batch.items()}
if self.config['use_ddp']: # ddp, gather data from all devices for evaluation
preds = self.model.module.predict(batch, n_return_sequences=self.evaluator.maxk)
all_preds, all_labels = self.accelerator.gather_for_metrics((preds, batch['labels']))
results = self.evaluator.calculate_metrics(all_preds, all_labels)
else:
preds = self.model.predict(batch, n_return_sequences=self.evaluator.maxk)
results = self.evaluator.calculate_metrics(preds, batch['labels'])
for key, value in results.items():
all_results[key].append(value)
output_results = OrderedDict()
for metric in self.config['metrics']:
for k in self.config['topk']:
key = f"{metric}@{k}"
output_results[key] = torch.cat(all_results[key]).mean().item()
return output_results
def end(self):
"""
Ends the training process and releases any used resources
"""
self.accelerator.end_training()