Download annotations/annotation_38/PreferDiff/trainer.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 5.47 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_38/PreferDiff/trainer.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_38/PreferDiff/trainer.py
-
curl -L -o trainer.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_38/PreferDiff/trainer.py
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() | |