| | |
|---|
| | | checkpoint["step_in_epoch"] if "step_in_epoch" in checkpoint else 0 |
|---|
| | | ) |
|---|
| | | self.step_in_epoch = 0 if self.step_in_epoch is None else self.step_in_epoch |
|---|
| | | print(checkpoint["train_acc_avg"]) |
|---|
| | | self.train_acc_avg = ( |
|---|
| | | checkpoint["train_acc_avg"] if "train_acc_avg" in checkpoint else 0 |
|---|
| | | ) |
|---|
| | |
|---|
| | | ): |
|---|
| | | torch.cuda.empty_cache() |
|---|
| | | |
|---|
| | | time3 = time.perf_counter() |
|---|
| | | speed_stats["forward_time"] = f"{time3 - time2:0.3f}" |
|---|
| | | loss, stats, weight = retval |
|---|
| | | stats = {k: v for k, v in stats.items() if v is not None} |
|---|
| | | if self.use_ddp or self.use_fsdp: |
|---|
| | | # Apply weighted averaging for loss and stats |
|---|
| | | loss = (loss * weight.type(loss.dtype)).sum() |
|---|
| | | # if distributed, this method can also apply all_reduce() |
|---|
| | | # stats, weight = recursive_average(stats, weight, distributed=True) |
|---|
| | | if self.use_ddp or self.use_fsdp: |
|---|
| | | dist.all_reduce(weight, op=dist.ReduceOp.SUM) |
|---|
| | | # Now weight is summation over all workers |
|---|
| | | loss /= weight.sum() # shape:[1] -> shape:[] |
|---|
| | | # Multiply world_size because DistributedDataParallel |
|---|
| | | # automatically normalizes the gradient by world_size. |
|---|
| | | loss *= self.world_size |
|---|
| | | # if self.use_ddp or self.use_fsdp: |
|---|
| | | # # Apply weighted averaging for loss and stats |
|---|
| | | # loss = (loss * weight.type(loss.dtype)).sum() |
|---|
| | | # # if distributed, this method can also apply all_reduce() |
|---|
| | | # # stats, weight = recursive_average(stats, weight, distributed=True) |
|---|
| | | # if self.use_ddp or self.use_fsdp: |
|---|
| | | # dist.all_reduce(weight, op=dist.ReduceOp.SUM) |
|---|
| | | # # Now weight is summation over all workers |
|---|
| | | # loss /= weight.sum() # shape:[1] -> shape:[] |
|---|
| | | # # Multiply world_size because DistributedDataParallel |
|---|
| | | # # automatically normalizes the gradient by world_size. |
|---|
| | | # loss *= self.world_size |
|---|
| | | loss *= self.world_size |
|---|
| | | # Scale the loss since we're not updating for every mini-batch |
|---|
| | | loss = loss / accum_grad |
|---|
| | | |
|---|
| | | time3 = time.perf_counter() |
|---|
| | | speed_stats["forward_time"] = f"{time3 - time2:0.3f}" |
|---|
| | | if self.use_fp16: |
|---|
| | | scaler.scale(loss).backward() |
|---|
| | | else: |
|---|
| | | loss.backward() |
|---|
| | | time4 = time.perf_counter() |
|---|
| | | speed_stats["backward_time"] = f"{time4 - time3:0.3f}" |
|---|
| | | speed_stats["backward_and_AllReaduce_time"] = f"{time4 - time3:0.3f}" |
|---|
| | | |
|---|
| | | self.train_loss_avg = ( |
|---|
| | | self.train_loss_avg * (self.step_in_epoch - 1) + loss.detach().cpu().item() |
|---|
| | |
|---|
| | | self.train_acc_avg * (self.step_in_epoch - 1) |
|---|
| | | + stats["acc"].detach().cpu().item() |
|---|
| | | ) / self.step_in_epoch |
|---|
| | | if self.use_ddp or self.use_fsdp: |
|---|
| | | train_loss_avg = torch.tensor(self.train_loss_avg, dtype=torch.float32).to( |
|---|
| | | self.device |
|---|
| | | ) |
|---|
| | | train_acc_avg = torch.tensor(self.train_acc_avg, dtype=torch.float32).to( |
|---|
| | | self.device |
|---|
| | | ) |
|---|
| | | dist.all_reduce(train_loss_avg, op=dist.ReduceOp.SUM) |
|---|
| | | dist.all_reduce(train_acc_avg, op=dist.ReduceOp.SUM) |
|---|
| | | self.train_loss_avg = train_loss_avg.detach().cpu().item() / self.world_size |
|---|
| | | self.train_acc_avg = train_acc_avg.detach().cpu().item() / self.world_size |
|---|
| | | |
|---|
| | | # Perform an optimizer step only after accumulating enough gradients |
|---|
| | | if (batch_idx + 1) % accum_grad == 0: |
|---|
| | |
|---|
| | | scheduler.step() |
|---|
| | | # Clear gradients for the next accumulation stage |
|---|
| | | optim.zero_grad(set_to_none=True) |
|---|
| | | total_time = f"{time.perf_counter() - time5:0.3f}" |
|---|
| | | total_time = f"{(time.perf_counter() - time5)/accum_grad:0.3f}" |
|---|
| | | time5 = time.perf_counter() |
|---|
| | | |
|---|
| | | if self.use_ddp or self.use_fsdp: |
|---|
| | | train_loss_avg = torch.tensor(self.train_loss_avg, dtype=torch.float32).to( |
|---|
| | | self.device |
|---|
| | | ) |
|---|
| | | train_acc_avg = torch.tensor(self.train_acc_avg, dtype=torch.float32).to( |
|---|
| | | self.device |
|---|
| | | ) |
|---|
| | | dist.all_reduce(train_loss_avg, op=dist.ReduceOp.SUM) |
|---|
| | | dist.all_reduce(train_acc_avg, op=dist.ReduceOp.SUM) |
|---|
| | | self.train_loss_avg = train_loss_avg.detach().cpu().item() / self.world_size |
|---|
| | | self.train_acc_avg = train_acc_avg.detach().cpu().item() / self.world_size |
|---|
| | | |
|---|
| | | speed_stats["optim_time"] = f"{time5 - time4:0.3f}" |
|---|
| | | |
|---|
| | | speed_stats["total_time"] = total_time |
|---|
| | |
|---|
| | | batch_num_epoch = len(dataloader_train) |
|---|
| | | self.log( |
|---|
| | | epoch, |
|---|
| | | batch_idx + kwargs.get("start_step", 0), |
|---|
| | | batch_idx, |
|---|
| | | log_step=batch_idx + kwargs.get("start_step", 0), |
|---|
| | | step_in_epoch=self.step_in_epoch, |
|---|
| | | batch_num_epoch=batch_num_epoch, |
|---|
| | | lr=lr, |
|---|
| | |
|---|
| | | tag="train", |
|---|
| | | data_split_i=0, |
|---|
| | | data_split_num=1, |
|---|
| | | log_step=None, |
|---|
| | | **kwargs, |
|---|
| | | ): |
|---|
| | | |
|---|
| | | if (batch_idx + 1) % self.log_interval == 0: |
|---|
| | | |
|---|
| | | batch_idx = log_step if log_step is not None else batch_idx |
|---|
| | | gpu_info = ( |
|---|
| | | "GPU, memory: usage: {:.3f} GB, " |
|---|
| | | "peak: {:.3f} GB, " |
|---|
