python/FunASR-XL.git

			@@ -85,7 +85,12 @@
			self.batch_total = 0
			self.use_fp16 = use_fp16
			self.save_checkpoint_interval = kwargs.get("save_checkpoint_interval", 5000)
			self.validate_interval = kwargs.get("validate_interval", 5000)
			self.validate_interval = kwargs.get("validate_interval", -1)
			if self.validate_interval < 0:
			self.validate_interval = self.save_checkpoint_interval
			assert (
			self.save_checkpoint_interval == self.validate_interval
			), f"save_checkpoint_interval must equal to validate_interval"
			self.keep_nbest_models = kwargs.get("keep_nbest_models", 500)
			self.avg_keep_nbest_models_type = kwargs.get("avg_keep_nbest_models_type", "acc")
			self.avg_nbest_model = kwargs.get("avg_nbest_model", 10)
			@@ -308,6 +313,7 @@
			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
			)
			@@ -356,10 +362,10 @@
			time_beg = time.perf_counter()
			time5 = time_beg
			for batch_idx, batch in enumerate(dataloader_train):
			if self.use_ddp or self.use_fsdp:
			dist.all_reduce(iterator_stop, dist.ReduceOp.SUM)
			if iterator_stop > 0:
			break
			# if self.use_ddp or self.use_fsdp:
			# dist.all_reduce(iterator_stop, dist.ReduceOp.SUM)
			# if iterator_stop > 0:
			# break
			self.batch_total += 1
			self.step_in_epoch += 1
			time1 = time.perf_counter()
			@@ -375,14 +381,12 @@
			with maybe_autocast(self.use_fp16):
			retval = model(**batch)

			if (
			self.reset_gpu_cache
			and (torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024) > 70
			):
			torch.cuda.empty_cache()
			# if (
			# self.reset_gpu_cache
			# and (torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024) > 70
			# ):
			# 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:
			@@ -397,34 +401,28 @@
			# 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.step_in_epoch
			self.train_loss_avg * (batch_idx + kwargs.get("start_step", 0))
			+ loss.detach().cpu().item()
			) / (batch_idx + kwargs.get("start_step", 0) + 1)
			if "acc" in stats:
			self.train_acc_avg = (
			self.train_acc_avg * (self.step_in_epoch - 1)
			self.train_acc_avg * (batch_idx + kwargs.get("start_step", 0))
			+ 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
			) / (batch_idx + kwargs.get("start_step", 0) + 1)

			# Perform an optimizer step only after accumulating enough gradients
			if (batch_idx + 1) % accum_grad == 0:
			@@ -453,8 +451,22 @@
			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}"

			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

			total_time = f"{(time.perf_counter() - time5)/accum_grad:0.3f}"
			time5 = time.perf_counter()

			speed_stats["optim_time"] = f"{time5 - time4:0.3f}"

			speed_stats["total_time"] = total_time
			@@ -464,11 +476,12 @@
			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,
			loss=loss.detach().cpu().item(),
			loss=accum_grad * loss.detach().cpu().item(),
			speed_stats=speed_stats,
			stats=stats,
			writer=writer,
			@@ -503,14 +516,14 @@
			)

			time_beg = time.perf_counter()
			else:
			if self.use_ddp or self.use_fsdp:
			iterator_stop.fill_(1)
			dist.all_reduce(iterator_stop, dist.ReduceOp.SUM)
			# else:
			# if self.use_ddp or self.use_fsdp:
			# iterator_stop.fill_(1)
			# dist.all_reduce(iterator_stop, dist.ReduceOp.SUM)

			if self.use_ddp or self.use_fsdp:
			dist.barrier()
			iterator_stop = torch.tensor(0).to(self.device)
			# iterator_stop = torch.tensor(0).to(self.device)

			def validate_epoch(
			self,
			@@ -633,11 +646,12 @@
			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, "
			@@ -659,9 +673,9 @@
			f"data_slice: {data_split_i}/{data_split_num}, "
			f"step_in_slice: {batch_idx + 1}/{batch_num_epoch}, step_in_epoch: {step_in_epoch}, total step: {self.batch_total}, "
			f"(loss_avg_rank: {loss:.3f}), "
			f"(loss_avg_epoch: {loss_avg_epoch:.3f}), "
			f"(ppl_avg_epoch: {math.exp(loss_avg_epoch):.3e}), "
			f"(acc_avg_epoch: {acc_avg_epoch:.3f}), "
			f"(loss_avg_slice: {loss_avg_epoch:.3f}), "
			f"(ppl_avg_slice: {math.exp(loss_avg_epoch):.3e}), "
			f"(acc_avg_slice: {acc_avg_epoch:.3f}), "
			f"(lr: {lr:.3e}), "
			f"{[(k, round(v.detach().cpu().item(), 3)) for k, v in stats.items()]}, "
			f"{speed_stats}, "