From 6b168c6b7412a2b0fab7610cecf04860137ca32e Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sun, 25 Jun 2023 10:12:35 +0000 Subject: [PATCH 01/57] Added support for lr_final --- RWKV-v4neo/src/model.py | 110 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 104 insertions(+), 6 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 1aa5eb98..51bd1724 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -2,7 +2,7 @@ # The RWKV Language Model - https://github.com/BlinkDL/RWKV-LM ######################################################################################################## -import os, math +import os, math, sys from random import randint from typing import List, Optional import numpy as np @@ -228,6 +228,9 @@ def __init__(self, vocab_size: int, grad_cp: bool, lr_init: float, + lr_final: float = -1.0, + lr_period: int = -1, + lr_period_type: str = 'epoch', warmup_steps: int = -1, beta1: float = 0.9, beta2: float = 0.99, @@ -248,6 +251,9 @@ def __init__(self, self.layerwise_lr = layerwise_lr self.grad_cp = grad_cp self.lr_init = lr_init + self.lr_final = lr_final + self.lr_period = lr_period + self.lr_period_type = lr_period_type self.warmup_steps = warmup_steps self.beta1 = beta1 self.beta2 = beta2 @@ -328,9 +334,15 @@ def configure_optimizers(self): }, ] + # Set ending_lr to starting_lr, as default behavior + starting_lr = self.lr_init + ending_lr = self.lr_final + if ending_lr < 0: + ending_lr = self.lr_init + if self.deepspeed_offload: optimizer = DeepSpeedCPUAdam(optim_groups, - lr=self.lr_init, + lr=starting_lr, betas=(self.beta1, self.beta2), eps=self.adam_eps, bias_correction=True, @@ -339,13 +351,18 @@ def configure_optimizers(self): amsgrad=False) else: optimizer = FusedAdam(optim_groups, - lr=self.lr_init, + lr=starting_lr, betas=(self.beta1, self.beta2), eps=self.adam_eps, bias_correction=True, adam_w_mode=False, weight_decay=self.weight_decay, amsgrad=False) + + # Throw if wramup_steps and lr_period are both set (not supported) + if self.warmup_steps > 0 and self.lr_period > 0: + raise ValueError( + "Use either warmup_steps or lr_period, not both.") if self.warmup_steps > 0: lr_scheduler = deepspeed.runtime.lr_schedules.WarmupLR( @@ -355,10 +372,83 @@ def configure_optimizers(self): warmup_num_steps=self.warmup_steps, warmup_type='linear') - return optimizer, lr_scheduler + return { + 'optimizer': optimizer, + 'lr_scheduler': lr_scheduler, + } + else: - return optimizer + # Skip the lr_scheduler process if lr_init and lr_final are the same + if starting_lr == ending_lr: + return optimizer + + # The total number of steps to perform training rate decay with + lr_total_step = 0 + + # Handle lr_period -1 default behaviour of using the max_step / max_epoch + if self.lr_period == -1: + # Get trainer max_step / max_epoch + trainer_max_step = self.trainer.max_steps + trainer_max_epoch = self.trainer.max_epochs + if trainer_max_step > 0: + lr_total_step = trainer_max_step + elif trainer_max_epoch > 0: + lr_total_step = trainer_max_epoch * self.num_step_per_epoch() + else : + print("Warning: max_step/max_epoch not set, we would be performing lr_init to lr_final shift assuming 10 epoch") + lr_total_step = 10 * self.num_step_per_epoch() + else: + # Calculate lr_total_step based on lr_period + if self.lr_period_type == "step": + lr_total_step = self.lr_period + elif self.lr_period_type == "epoch": + lr_total_step = self.lr_period * self.num_step_per_epoch() + else: + raise ValueError(f"lr_period_type {self.lr_period_type} not supported.") + # Lets initialize the lr_scheduler + lr_scheduler = torch.optim.lr_scheduler.LinearLR( + optimizer, + start_factor=1.0, + end_factor= ending_lr / starting_lr, + total_iters=lr_total_step + ) + + return { + 'optimizer': optimizer, + 'lr_scheduler': { + "scheduler": lr_scheduler, + "interval": "step", + "frequency": 1, + }, + } + + + # We have to compute the number of steps per epoch ourselves + # as this value is not provided directly by pytorch lightning + # https://github.com/Lightning-AI/lightning/issues/5449#issuecomment-1501597319 + def num_step_per_epoch(self) -> int: + # Estimated number of steps in total, added as the following + # https://github.com/Lightning-AI/lightning/pull/11599 + # + # This MUST be called before len(self.trainer.train_loader) + # otherwise there is a bug in which the train_dataloader is not + # fully initialized, which seems to be resolved by computing the + # self.trainer.estimated_stepping_batches + estimated_stepping_batches = self.trainer.estimated_stepping_batches + + # Get the number of epochs, + # use estimated_stepping_batches if max_epochs is set + max_epochs = self.trainer.max_epochs + if max_epochs > 0: + return estimated_stepping_batches // max_epochs + + # Max epoch is not set, use the train_dataloader + dataset_size = len(self.trainer.train_dataloader) + num_devices = max(1, self.trainer.num_devices) + num_steps = dataset_size // (self.trainer.accumulate_grad_batches * num_devices) + return num_steps + @property def deepspeed_offload(self) -> bool: strategy = self.trainer.strategy @@ -474,7 +564,15 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_states, # Wandb logging only, if an active run exists if wandb.run is not None: - wandb.log({'substep': batch_idx, 'real_ctx_len': T, 'train/loss': total_loss, 'trainer/global_step':self.global_step}) + # Get the current learning rate + lr = self.trainer.optimizers[0].param_groups[0]['lr'] + wandb.log({ + 'substep': batch_idx, + 'real_ctx_len': T, + 'train/loss': total_loss, + 'trainer/global_step':self.global_step, + 'trainer/learning_rate': lr + }) return total_loss From e2cd3acc032e9e361262ab897b110bd8cb85109d Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Tue, 4 Jul 2023 12:43:53 +0000 Subject: [PATCH 02/57] Introduction of bptt_learning --- RWKV-v4neo/src/model.py | 240 ++++++++++++++++++++++++++++++++-------- 1 file changed, 196 insertions(+), 44 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index b6029652..16ff9a7c 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -2,7 +2,7 @@ # The RWKV Language Model - https://github.com/BlinkDL/RWKV-LM ######################################################################################################## -import os, math, sys +import gc, math from random import randint from typing import List, Optional @@ -262,11 +262,14 @@ def __init__(self, beta2: float = 0.99, adam_eps: float = 1.0e-08, weight_decay: float = 0.01, + bptt_learning: bool = True, + bptt_learning_range: int = -1, + bptt_truncated_learning: bool = False, layerwise_lr: bool = True, dim_att: Optional[int] = None, dim_ffn: Optional[int] = None, load_model: Optional[str] = None, - torch_set_float32_matmul_precision:str = None + torch_set_float32_matmul_precision:str = 'high' ): super().__init__() self.ctx_len = ctx_len @@ -285,6 +288,9 @@ def __init__(self, self.beta2 = beta2 self.weight_decay = weight_decay self.adam_eps = adam_eps + self.bptt_learning = bptt_learning + self.bptt_learning_range = bptt_learning_range + self.bptt_truncated_learning = bptt_truncated_learning dim_att = dim_att or n_embd dim_ffn = dim_ffn or n_embd * 4 @@ -315,6 +321,12 @@ def __init__(self, self.load_state_dict(torch.load(load_model, map_location='cpu')) def configure_optimizers(self): + if self.bptt_learning == False: + if self.deepspeed_stage >= 2 or self.deepspeed_offload: + print("[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length ({self.ctx_len})") + else: + if self.trainer.num_devices > 1 and (self.bptt_learning_range <= -1 or self.bptt_learning_range > 1): + raise NotImplementedError("bptt_learning_range must be limited to 1 in multi-gpu training, due to existing issues where `backprop(retain_graph=True)` where it hangs in multi-gpu training") if self.layerwise_lr: lr_1x = set() lr_2x = set() @@ -402,7 +414,6 @@ def configure_optimizers(self): 'optimizer': optimizer, 'lr_scheduler': lr_scheduler, } - else: # Skip the lr_scheduler process if lr_init and lr_final are the same if starting_lr == ending_lr: @@ -469,8 +480,13 @@ def num_step_per_epoch(self) -> int: if max_epochs > 0: return estimated_stepping_batches // max_epochs + # Get the train_dataloader + train_dataloader = self.trainer.train_dataloader + if( train_dataloader is None ): + train_dataloader = self.trainer.fit_loop._data_source.dataloader() + # Max epoch is not set, use the train_dataloader - dataset_size = len(self.trainer.train_dataloader) + dataset_size = len(train_dataloader) num_devices = max(1, self.trainer.num_devices) num_steps = dataset_size // (self.trainer.accumulate_grad_batches * num_devices) return num_steps @@ -482,6 +498,14 @@ def deepspeed_offload(self) -> bool: cfg = strategy.config["zero_optimization"] return "offload_optimizer" in cfg or "offload_parameters" in cfg return False + + @property + def deepspeed_stage(self) -> int: + strategy = self.trainer.strategy + if isinstance(strategy, DeepSpeedStrategy): + cfg = strategy.config["zero_optimization"] + return "stage" in cfg + return -1 def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, last_wkv_states: torch.Tensor): @@ -508,7 +532,47 @@ def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, return x, new_states.shift_states, new_states.wkv_states - def compute_loss(self, batch, batch_idx, do_cutoff: bool): + # + # Custom overwrite of manual_backwards operation, to skip the "manual_backwards" + # safety check, so we can perform manual backward operation step, while using + # the default trainer loop. This is modified from the original code found here: + # https://github.com/Lightning-AI/lightning/blob/37c244f94be365496def82870b22c2faf0ab889e/src/lightning/pytorch/core/module.py#L999 + # + # --- + # + # This allow us to avoid disabling the "automatic_optimization" flag + # + # Which would have been required to do "segmented learning", or "Truncated Backpropagation Through Time" + # where we would need to implement manual optimization as per + # https://lightning.ai/docs/pytorch/stable/model/manual_optimization.html + # + # Otherwise an error will be thrown if we call `self.manual_backward` + # + # However this would mean that we would need to do a full reimplementation + # of several features that were handled by the automatic optimization. + # - accumulate_grad_batches + # - gradient_clip_val + # - logging behaviour + # - distributed training co-ordination + # - (And probably other features that I am not aware of) + # + # So this is a hacky work around, to avoid reimplementing all of the above. + # + # From the current code implementatiion, it seem like this is blocked only by + # automatic_optimization flag - and has no adverse side effect otherwise + # https://lightning.ai/docs/pytorch/stable/_modules/lightning/pytorch/core/module.html#LightningModule.manual_backward + # + # If anyone have a better idea, let me know + # (have experimented with, reimplementing the above, but it is not trivial, unfortunately) + # + def manual_backward(self, loss: torch.Tensor, *args, **kwargs): + if self._fabric: + self._fabric.backward(loss, *args, **kwargs) + else: + # self._verify_is_manual_optimization("manual_backward") + self.trainer.strategy.backward(loss, None, *args, **kwargs) + + def compute_loss(self, batch, batch_idx, is_training_run: bool): seq = batch['input_ids'] assert isinstance(seq, torch.Tensor) and seq.ndim == 2 seq_mask = batch['attention_mask'] @@ -517,7 +581,8 @@ def compute_loss(self, batch, batch_idx, do_cutoff: bool): if seq_mask is None or seq_mask.ndim != 2: seq_mask = torch.ones_like(seq[:, 1:]) - if do_cutoff: + # Perform cutoff for training run + if is_training_run: prev_step = 0 for step, len_cut in zip(self.ctx_len_warmup_steps, self.ctx_len_cutoffs): @@ -535,13 +600,18 @@ def compute_loss(self, batch, batch_idx, do_cutoff: bool): seq_mask[:, :pos] = 0 break prev_step = step - + + do_bptt_learning = self.bptt_learning and is_training_run idx, targets = seq[:, :-1], seq[:, 1:] B, T = idx.shape C = self.n_embd total_mask_sum = torch.sum(seq_mask) + # If total_mask_sum, we skip, as there is no tokens of value to learn from anyway + if total_mask_sum == 0: + return 0 + def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, last_wkv_states, prev_steps): logits, new_shift_states, new_wkv_states = self( @@ -552,21 +622,10 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, submask = mask.view(-1)[:loss.shape[0]] submask_sum = torch.sum(submask) - # Special handling of empty mask - # (possible when real_ctx_len is larger then ctx_len, which results into 'chunking') - if submask_sum == 0: - loss = torch.sum(loss * submask) / 1 - loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) - new_steps = prev_steps # + submask_sum - new_loss = prev_loss + loss - else: - # Handling with mask - loss = torch.sum(loss * submask) / submask_sum - loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) - new_steps = prev_steps + submask_sum - new_loss = prev_loss * (prev_steps / new_steps) + loss * ( - 1 - prev_steps / new_steps) - + loss = torch.sum(loss * submask) / total_mask_sum + loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) + new_steps = prev_steps + submask_sum + new_loss = prev_loss + loss return new_loss, new_shift_states, new_wkv_states, new_steps total_loss = torch.tensor( @@ -574,31 +633,116 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, steps = 0 states = BlockStateList.create(self.n_layer, B, C, seq.device, self.emb.weight.dtype) - for i in range(math.ceil(T / self.ctx_len)): - if i != math.ceil(T / self.ctx_len) - 1: - total_loss, new_shift_states, new_wkv_states, steps = deepspeed.checkpointing.checkpoint( - checkpointed_step, - idx[:, i * self.ctx_len:(i + 1) * self.ctx_len], - targets[:, i * self.ctx_len:(i + 1) * self.ctx_len], - seq_mask[:, i * self.ctx_len:(i + 1) * self.ctx_len], - total_loss, - states.shift_states, - states.wkv_states, - steps, - ) + segment_count = math.ceil(T / self.ctx_len) + + # + # TBPTT learning, we split the sequence into segments + # and perform a backward pass for each segment, on its own. + # + # Allowing us to perform backpropagation across context sizes much larger + # then what is supported by the current GPU memory. + # + # This reduces the need for the checkpointing process, and mitigate + # a known error where multiple backwards pass throws an exception. + # + # While not mathematically equivalent to full context size learning, + # it makes "infctx" size training possible with deepspeed 2/3 + # + # --- + # + # See the following, for more details on "Gradient computed twice" error: + # https://github.com/microsoft/DeepSpeed/issues/988#issuecomment-1549417269 + # + # Other possibly related issues on the topic: + # https://github.com/microsoft/DeepSpeed/pull/677 + # https://github.com/EleutherAI/gpt-neox/issues/62#issuecomment-766366413 + # + if do_bptt_learning: + + # Get the optimizer + optimizer = self.optimizers() + + # We get the average segment size, instead of ctx length size. + # this helps ensure that the segment cutoffs do not make the last segment too small, + # it also helps ensure the segment cutoff points are more varied, across mixed dataset sizes + # to avoid potentially undesired training behaviour at fixed cutoff points + # (this only applies for segmented learning) + segment_size = min(math.ceil(T / segment_count), self.ctx_len) + + # Segmented learning range + if self.bptt_learning_range > 0: + first_learning_segment = segment_count - self.bptt_learning_range; else: - total_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( - idx[:, i * self.ctx_len:(i + 1) * self.ctx_len], - targets[:, i * self.ctx_len:(i + 1) * self.ctx_len], - seq_mask[:, i * self.ctx_len:(i + 1) * self.ctx_len], - total_loss, - states.shift_states, - states.wkv_states, + first_learning_segment = 0; + + for i in range(segment_count): + # Apply state truncation, if truncated learning is enabled + if self.bptt_truncated_learning: + prv_shift_states = states.shift_states.clone().detach().requires_grad_(False) + prv_wkv_states = states.wkv_states.clone().detach().requires_grad_(False) + else: + prv_shift_states = states.shift_states + prv_wkv_states = states.wkv_states + + # Segmented learning, applies the forward/pass over each chunk seperately + segment_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( + idx[:, i * segment_size:(i + 1) * segment_size], + targets[:, i * segment_size:(i + 1) * segment_size], + seq_mask[:, i * segment_size:(i + 1) * segment_size], + torch.tensor(0, dtype=self.emb.weight.dtype).requires_grad_(True), + prv_shift_states, + prv_wkv_states, steps, ) - states = BlockStateList(new_shift_states, new_wkv_states) - gc.collect() - # torch.cuda.empty_cache() + states = BlockStateList(new_shift_states, new_wkv_states) + + # Compute the backward pass for the segment + if i >= first_learning_segment: + if i == segment_count-1: + # This is the last pass, we can drop the graph after this + self.manual_backward(segment_loss, optimizer) + else: + # Undocumented multiple backward pass support + # https://discord.com/channels/992359628979568762/1123248764132524242/1125374974597795920 + self.manual_backward(segment_loss, optimizer, retain_graph=True) + + # Accumulate the total loss, since there is nothing to backprop here + # its respective "backward pass" should be a no-op + total_loss = total_loss + segment_loss.clone().detach().requires_grad_(False) + + # GC collect unused memory + gc.collect() + # torch.cuda.empty_cache() + else: + + # Normal operations without TBPTT + segment_size = self.ctx_len + for i in range(segment_count): + if i < segment_count-1: + total_loss, new_shift_states, new_wkv_states, steps = deepspeed.checkpointing.checkpoint( + checkpointed_step, + idx[:, i * segment_size:(i + 1) * segment_size], + targets[:, i * segment_size:(i + 1) * segment_size], + seq_mask[:, i * segment_size:(i + 1) * segment_size], + total_loss, + states.shift_states, + states.wkv_states, + steps, + ) + else: + total_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( + idx[:, i * segment_size:(i + 1) * segment_size], + targets[:, i * segment_size:(i + 1) * segment_size], + seq_mask[:, i * segment_size:(i + 1) * segment_size], + total_loss, + states.shift_states, + states.wkv_states, + steps, + ) + + states = BlockStateList(new_shift_states, new_wkv_states) + gc.collect() + # torch.cuda.empty_cache() # Wandb logging only, if an active run exists if wandb.run is not None: @@ -615,6 +759,14 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, def training_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, True) self.log('train/loss', total_loss, prog_bar=True) + + # # The following barrier is required to syncronize the trainig step across all GPUs before + # # the optimizer step is performed for each batch. Otherwise a "hanged state" can occur. + # # + # # This is suppose to help with multi-gpu training (did not work) + # if (batch_idx + 1) % self.trainer.accumulate_grad_batches == 0: + # self.trainer.getFabric().barrier() + return total_loss def validation_step(self, batch, batch_idx): From bdf4eae21426a0149382a4d6589e8e7adf0e4e7e Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Tue, 4 Jul 2023 12:45:16 +0000 Subject: [PATCH 03/57] Revert "Introduction of bptt_learning" This reverts commit e2cd3acc032e9e361262ab897b110bd8cb85109d. --- RWKV-v4neo/src/model.py | 240 ++++++++-------------------------------- 1 file changed, 44 insertions(+), 196 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 16ff9a7c..b6029652 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -2,7 +2,7 @@ # The RWKV Language Model - https://github.com/BlinkDL/RWKV-LM ######################################################################################################## -import gc, math +import os, math, sys from random import randint from typing import List, Optional @@ -262,14 +262,11 @@ def __init__(self, beta2: float = 0.99, adam_eps: float = 1.0e-08, weight_decay: float = 0.01, - bptt_learning: bool = True, - bptt_learning_range: int = -1, - bptt_truncated_learning: bool = False, layerwise_lr: bool = True, dim_att: Optional[int] = None, dim_ffn: Optional[int] = None, load_model: Optional[str] = None, - torch_set_float32_matmul_precision:str = 'high' + torch_set_float32_matmul_precision:str = None ): super().__init__() self.ctx_len = ctx_len @@ -288,9 +285,6 @@ def __init__(self, self.beta2 = beta2 self.weight_decay = weight_decay self.adam_eps = adam_eps - self.bptt_learning = bptt_learning - self.bptt_learning_range = bptt_learning_range - self.bptt_truncated_learning = bptt_truncated_learning dim_att = dim_att or n_embd dim_ffn = dim_ffn or n_embd * 4 @@ -321,12 +315,6 @@ def __init__(self, self.load_state_dict(torch.load(load_model, map_location='cpu')) def configure_optimizers(self): - if self.bptt_learning == False: - if self.deepspeed_stage >= 2 or self.deepspeed_offload: - print("[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length ({self.ctx_len})") - else: - if self.trainer.num_devices > 1 and (self.bptt_learning_range <= -1 or self.bptt_learning_range > 1): - raise NotImplementedError("bptt_learning_range must be limited to 1 in multi-gpu training, due to existing issues where `backprop(retain_graph=True)` where it hangs in multi-gpu training") if self.layerwise_lr: lr_1x = set() lr_2x = set() @@ -414,6 +402,7 @@ def configure_optimizers(self): 'optimizer': optimizer, 'lr_scheduler': lr_scheduler, } + else: # Skip the lr_scheduler process if lr_init and lr_final are the same if starting_lr == ending_lr: @@ -480,13 +469,8 @@ def num_step_per_epoch(self) -> int: if max_epochs > 0: return estimated_stepping_batches // max_epochs - # Get the train_dataloader - train_dataloader = self.trainer.train_dataloader - if( train_dataloader is None ): - train_dataloader = self.trainer.fit_loop._data_source.dataloader() - # Max epoch is not set, use the train_dataloader - dataset_size = len(train_dataloader) + dataset_size = len(self.trainer.train_dataloader) num_devices = max(1, self.trainer.num_devices) num_steps = dataset_size // (self.trainer.accumulate_grad_batches * num_devices) return num_steps @@ -498,14 +482,6 @@ def deepspeed_offload(self) -> bool: cfg = strategy.config["zero_optimization"] return "offload_optimizer" in cfg or "offload_parameters" in cfg return False - - @property - def deepspeed_stage(self) -> int: - strategy = self.trainer.strategy - if isinstance(strategy, DeepSpeedStrategy): - cfg = strategy.config["zero_optimization"] - return "stage" in cfg - return -1 def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, last_wkv_states: torch.Tensor): @@ -532,47 +508,7 @@ def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, return x, new_states.shift_states, new_states.wkv_states - # - # Custom overwrite of manual_backwards operation, to skip the "manual_backwards" - # safety check, so we can perform manual backward operation step, while using - # the default trainer loop. This is modified from the original code found here: - # https://github.com/Lightning-AI/lightning/blob/37c244f94be365496def82870b22c2faf0ab889e/src/lightning/pytorch/core/module.py#L999 - # - # --- - # - # This allow us to avoid disabling the "automatic_optimization" flag - # - # Which would have been required to do "segmented learning", or "Truncated Backpropagation Through Time" - # where we would need to implement manual optimization as per - # https://lightning.ai/docs/pytorch/stable/model/manual_optimization.html - # - # Otherwise an error will be thrown if we call `self.manual_backward` - # - # However this would mean that we would need to do a full reimplementation - # of several features that were handled by the automatic optimization. - # - accumulate_grad_batches - # - gradient_clip_val - # - logging behaviour - # - distributed training co-ordination - # - (And probably other features that I am not aware of) - # - # So this is a hacky work around, to avoid reimplementing all of the above. - # - # From the current code implementatiion, it seem like this is blocked only by - # automatic_optimization flag - and has no adverse side effect otherwise - # https://lightning.ai/docs/pytorch/stable/_modules/lightning/pytorch/core/module.html#LightningModule.manual_backward - # - # If anyone have a better idea, let me know - # (have experimented with, reimplementing the above, but it is not trivial, unfortunately) - # - def manual_backward(self, loss: torch.Tensor, *args, **kwargs): - if self._fabric: - self._fabric.backward(loss, *args, **kwargs) - else: - # self._verify_is_manual_optimization("manual_backward") - self.trainer.strategy.backward(loss, None, *args, **kwargs) - - def compute_loss(self, batch, batch_idx, is_training_run: bool): + def compute_loss(self, batch, batch_idx, do_cutoff: bool): seq = batch['input_ids'] assert isinstance(seq, torch.Tensor) and seq.ndim == 2 seq_mask = batch['attention_mask'] @@ -581,8 +517,7 @@ def compute_loss(self, batch, batch_idx, is_training_run: bool): if seq_mask is None or seq_mask.ndim != 2: seq_mask = torch.ones_like(seq[:, 1:]) - # Perform cutoff for training run - if is_training_run: + if do_cutoff: prev_step = 0 for step, len_cut in zip(self.ctx_len_warmup_steps, self.ctx_len_cutoffs): @@ -600,18 +535,13 @@ def compute_loss(self, batch, batch_idx, is_training_run: bool): seq_mask[:, :pos] = 0 break prev_step = step - - do_bptt_learning = self.bptt_learning and is_training_run + idx, targets = seq[:, :-1], seq[:, 1:] B, T = idx.shape C = self.n_embd total_mask_sum = torch.sum(seq_mask) - # If total_mask_sum, we skip, as there is no tokens of value to learn from anyway - if total_mask_sum == 0: - return 0 - def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, last_wkv_states, prev_steps): logits, new_shift_states, new_wkv_states = self( @@ -622,10 +552,21 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, submask = mask.view(-1)[:loss.shape[0]] submask_sum = torch.sum(submask) - loss = torch.sum(loss * submask) / total_mask_sum - loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) - new_steps = prev_steps + submask_sum - new_loss = prev_loss + loss + # Special handling of empty mask + # (possible when real_ctx_len is larger then ctx_len, which results into 'chunking') + if submask_sum == 0: + loss = torch.sum(loss * submask) / 1 + loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) + new_steps = prev_steps # + submask_sum + new_loss = prev_loss + loss + else: + # Handling with mask + loss = torch.sum(loss * submask) / submask_sum + loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) + new_steps = prev_steps + submask_sum + new_loss = prev_loss * (prev_steps / new_steps) + loss * ( + 1 - prev_steps / new_steps) + return new_loss, new_shift_states, new_wkv_states, new_steps total_loss = torch.tensor( @@ -633,116 +574,31 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, steps = 0 states = BlockStateList.create(self.n_layer, B, C, seq.device, self.emb.weight.dtype) - segment_count = math.ceil(T / self.ctx_len) - - # - # TBPTT learning, we split the sequence into segments - # and perform a backward pass for each segment, on its own. - # - # Allowing us to perform backpropagation across context sizes much larger - # then what is supported by the current GPU memory. - # - # This reduces the need for the checkpointing process, and mitigate - # a known error where multiple backwards pass throws an exception. - # - # While not mathematically equivalent to full context size learning, - # it makes "infctx" size training possible with deepspeed 2/3 - # - # --- - # - # See the following, for more details on "Gradient computed twice" error: - # https://github.com/microsoft/DeepSpeed/issues/988#issuecomment-1549417269 - # - # Other possibly related issues on the topic: - # https://github.com/microsoft/DeepSpeed/pull/677 - # https://github.com/EleutherAI/gpt-neox/issues/62#issuecomment-766366413 - # - if do_bptt_learning: - - # Get the optimizer - optimizer = self.optimizers() - - # We get the average segment size, instead of ctx length size. - # this helps ensure that the segment cutoffs do not make the last segment too small, - # it also helps ensure the segment cutoff points are more varied, across mixed dataset sizes - # to avoid potentially undesired training behaviour at fixed cutoff points - # (this only applies for segmented learning) - segment_size = min(math.ceil(T / segment_count), self.ctx_len) - - # Segmented learning range - if self.bptt_learning_range > 0: - first_learning_segment = segment_count - self.bptt_learning_range; + for i in range(math.ceil(T / self.ctx_len)): + if i != math.ceil(T / self.ctx_len) - 1: + total_loss, new_shift_states, new_wkv_states, steps = deepspeed.checkpointing.checkpoint( + checkpointed_step, + idx[:, i * self.ctx_len:(i + 1) * self.ctx_len], + targets[:, i * self.ctx_len:(i + 1) * self.ctx_len], + seq_mask[:, i * self.ctx_len:(i + 1) * self.ctx_len], + total_loss, + states.shift_states, + states.wkv_states, + steps, + ) else: - first_learning_segment = 0; - - for i in range(segment_count): - # Apply state truncation, if truncated learning is enabled - if self.bptt_truncated_learning: - prv_shift_states = states.shift_states.clone().detach().requires_grad_(False) - prv_wkv_states = states.wkv_states.clone().detach().requires_grad_(False) - else: - prv_shift_states = states.shift_states - prv_wkv_states = states.wkv_states - - # Segmented learning, applies the forward/pass over each chunk seperately - segment_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( - idx[:, i * segment_size:(i + 1) * segment_size], - targets[:, i * segment_size:(i + 1) * segment_size], - seq_mask[:, i * segment_size:(i + 1) * segment_size], - torch.tensor(0, dtype=self.emb.weight.dtype).requires_grad_(True), - prv_shift_states, - prv_wkv_states, + total_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( + idx[:, i * self.ctx_len:(i + 1) * self.ctx_len], + targets[:, i * self.ctx_len:(i + 1) * self.ctx_len], + seq_mask[:, i * self.ctx_len:(i + 1) * self.ctx_len], + total_loss, + states.shift_states, + states.wkv_states, steps, ) - states = BlockStateList(new_shift_states, new_wkv_states) - - # Compute the backward pass for the segment - if i >= first_learning_segment: - if i == segment_count-1: - # This is the last pass, we can drop the graph after this - self.manual_backward(segment_loss, optimizer) - else: - # Undocumented multiple backward pass support - # https://discord.com/channels/992359628979568762/1123248764132524242/1125374974597795920 - self.manual_backward(segment_loss, optimizer, retain_graph=True) - - # Accumulate the total loss, since there is nothing to backprop here - # its respective "backward pass" should be a no-op - total_loss = total_loss + segment_loss.clone().detach().requires_grad_(False) - - # GC collect unused memory - gc.collect() - # torch.cuda.empty_cache() - else: - - # Normal operations without TBPTT - segment_size = self.ctx_len - for i in range(segment_count): - if i < segment_count-1: - total_loss, new_shift_states, new_wkv_states, steps = deepspeed.checkpointing.checkpoint( - checkpointed_step, - idx[:, i * segment_size:(i + 1) * segment_size], - targets[:, i * segment_size:(i + 1) * segment_size], - seq_mask[:, i * segment_size:(i + 1) * segment_size], - total_loss, - states.shift_states, - states.wkv_states, - steps, - ) - else: - total_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( - idx[:, i * segment_size:(i + 1) * segment_size], - targets[:, i * segment_size:(i + 1) * segment_size], - seq_mask[:, i * segment_size:(i + 1) * segment_size], - total_loss, - states.shift_states, - states.wkv_states, - steps, - ) - - states = BlockStateList(new_shift_states, new_wkv_states) - gc.collect() - # torch.cuda.empty_cache() + states = BlockStateList(new_shift_states, new_wkv_states) + gc.collect() + # torch.cuda.empty_cache() # Wandb logging only, if an active run exists if wandb.run is not None: @@ -759,14 +615,6 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, def training_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, True) self.log('train/loss', total_loss, prog_bar=True) - - # # The following barrier is required to syncronize the trainig step across all GPUs before - # # the optimizer step is performed for each batch. Otherwise a "hanged state" can occur. - # # - # # This is suppose to help with multi-gpu training (did not work) - # if (batch_idx + 1) % self.trainer.accumulate_grad_batches == 0: - # self.trainer.getFabric().barrier() - return total_loss def validation_step(self, batch, batch_idx): From 66b870395c26bb69afe042b9afef2f749cd10870 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Tue, 4 Jul 2023 12:46:41 +0000 Subject: [PATCH 04/57] bptt_training param support --- RWKV-v4neo/src/model.py | 240 ++++++++++++++++++++++++++++++++-------- 1 file changed, 196 insertions(+), 44 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index b6029652..16ff9a7c 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -2,7 +2,7 @@ # The RWKV Language Model - https://github.com/BlinkDL/RWKV-LM ######################################################################################################## -import os, math, sys +import gc, math from random import randint from typing import List, Optional @@ -262,11 +262,14 @@ def __init__(self, beta2: float = 0.99, adam_eps: float = 1.0e-08, weight_decay: float = 0.01, + bptt_learning: bool = True, + bptt_learning_range: int = -1, + bptt_truncated_learning: bool = False, layerwise_lr: bool = True, dim_att: Optional[int] = None, dim_ffn: Optional[int] = None, load_model: Optional[str] = None, - torch_set_float32_matmul_precision:str = None + torch_set_float32_matmul_precision:str = 'high' ): super().__init__() self.ctx_len = ctx_len @@ -285,6 +288,9 @@ def __init__(self, self.beta2 = beta2 self.weight_decay = weight_decay self.adam_eps = adam_eps + self.bptt_learning = bptt_learning + self.bptt_learning_range = bptt_learning_range + self.bptt_truncated_learning = bptt_truncated_learning dim_att = dim_att or n_embd dim_ffn = dim_ffn or n_embd * 4 @@ -315,6 +321,12 @@ def __init__(self, self.load_state_dict(torch.load(load_model, map_location='cpu')) def configure_optimizers(self): + if self.bptt_learning == False: + if self.deepspeed_stage >= 2 or self.deepspeed_offload: + print("[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length ({self.ctx_len})") + else: + if self.trainer.num_devices > 1 and (self.bptt_learning_range <= -1 or self.bptt_learning_range > 1): + raise NotImplementedError("bptt_learning_range must be limited to 1 in multi-gpu training, due to existing issues where `backprop(retain_graph=True)` where it hangs in multi-gpu training") if self.layerwise_lr: lr_1x = set() lr_2x = set() @@ -402,7 +414,6 @@ def configure_optimizers(self): 'optimizer': optimizer, 'lr_scheduler': lr_scheduler, } - else: # Skip the lr_scheduler process if lr_init and lr_final are the same if starting_lr == ending_lr: @@ -469,8 +480,13 @@ def num_step_per_epoch(self) -> int: if max_epochs > 0: return estimated_stepping_batches // max_epochs + # Get the train_dataloader + train_dataloader = self.trainer.train_dataloader + if( train_dataloader is None ): + train_dataloader = self.trainer.fit_loop._data_source.dataloader() + # Max epoch is not set, use the train_dataloader - dataset_size = len(self.trainer.train_dataloader) + dataset_size = len(train_dataloader) num_devices = max(1, self.trainer.num_devices) num_steps = dataset_size // (self.trainer.accumulate_grad_batches * num_devices) return num_steps @@ -482,6 +498,14 @@ def deepspeed_offload(self) -> bool: cfg = strategy.config["zero_optimization"] return "offload_optimizer" in cfg or "offload_parameters" in cfg return False + + @property + def deepspeed_stage(self) -> int: + strategy = self.trainer.strategy + if isinstance(strategy, DeepSpeedStrategy): + cfg = strategy.config["zero_optimization"] + return "stage" in cfg + return -1 def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, last_wkv_states: torch.Tensor): @@ -508,7 +532,47 @@ def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, return x, new_states.shift_states, new_states.wkv_states - def compute_loss(self, batch, batch_idx, do_cutoff: bool): + # + # Custom overwrite of manual_backwards operation, to skip the "manual_backwards" + # safety check, so we can perform manual backward operation step, while using + # the default trainer loop. This is modified from the original code found here: + # https://github.com/Lightning-AI/lightning/blob/37c244f94be365496def82870b22c2faf0ab889e/src/lightning/pytorch/core/module.py#L999 + # + # --- + # + # This allow us to avoid disabling the "automatic_optimization" flag + # + # Which would have been required to do "segmented learning", or "Truncated Backpropagation Through Time" + # where we would need to implement manual optimization as per + # https://lightning.ai/docs/pytorch/stable/model/manual_optimization.html + # + # Otherwise an error will be thrown if we call `self.manual_backward` + # + # However this would mean that we would need to do a full reimplementation + # of several features that were handled by the automatic optimization. + # - accumulate_grad_batches + # - gradient_clip_val + # - logging behaviour + # - distributed training co-ordination + # - (And probably other features that I am not aware of) + # + # So this is a hacky work around, to avoid reimplementing all of the above. + # + # From the current code implementatiion, it seem like this is blocked only by + # automatic_optimization flag - and has no adverse side effect otherwise + # https://lightning.ai/docs/pytorch/stable/_modules/lightning/pytorch/core/module.html#LightningModule.manual_backward + # + # If anyone have a better idea, let me know + # (have experimented with, reimplementing the above, but it is not trivial, unfortunately) + # + def manual_backward(self, loss: torch.Tensor, *args, **kwargs): + if self._fabric: + self._fabric.backward(loss, *args, **kwargs) + else: + # self._verify_is_manual_optimization("manual_backward") + self.trainer.strategy.backward(loss, None, *args, **kwargs) + + def compute_loss(self, batch, batch_idx, is_training_run: bool): seq = batch['input_ids'] assert isinstance(seq, torch.Tensor) and seq.ndim == 2 seq_mask = batch['attention_mask'] @@ -517,7 +581,8 @@ def compute_loss(self, batch, batch_idx, do_cutoff: bool): if seq_mask is None or seq_mask.ndim != 2: seq_mask = torch.ones_like(seq[:, 1:]) - if do_cutoff: + # Perform cutoff for training run + if is_training_run: prev_step = 0 for step, len_cut in zip(self.ctx_len_warmup_steps, self.ctx_len_cutoffs): @@ -535,13 +600,18 @@ def compute_loss(self, batch, batch_idx, do_cutoff: bool): seq_mask[:, :pos] = 0 break prev_step = step - + + do_bptt_learning = self.bptt_learning and is_training_run idx, targets = seq[:, :-1], seq[:, 1:] B, T = idx.shape C = self.n_embd total_mask_sum = torch.sum(seq_mask) + # If total_mask_sum, we skip, as there is no tokens of value to learn from anyway + if total_mask_sum == 0: + return 0 + def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, last_wkv_states, prev_steps): logits, new_shift_states, new_wkv_states = self( @@ -552,21 +622,10 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, submask = mask.view(-1)[:loss.shape[0]] submask_sum = torch.sum(submask) - # Special handling of empty mask - # (possible when real_ctx_len is larger then ctx_len, which results into 'chunking') - if submask_sum == 0: - loss = torch.sum(loss * submask) / 1 - loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) - new_steps = prev_steps # + submask_sum - new_loss = prev_loss + loss - else: - # Handling with mask - loss = torch.sum(loss * submask) / submask_sum - loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) - new_steps = prev_steps + submask_sum - new_loss = prev_loss * (prev_steps / new_steps) + loss * ( - 1 - prev_steps / new_steps) - + loss = torch.sum(loss * submask) / total_mask_sum + loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) + new_steps = prev_steps + submask_sum + new_loss = prev_loss + loss return new_loss, new_shift_states, new_wkv_states, new_steps total_loss = torch.tensor( @@ -574,31 +633,116 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, steps = 0 states = BlockStateList.create(self.n_layer, B, C, seq.device, self.emb.weight.dtype) - for i in range(math.ceil(T / self.ctx_len)): - if i != math.ceil(T / self.ctx_len) - 1: - total_loss, new_shift_states, new_wkv_states, steps = deepspeed.checkpointing.checkpoint( - checkpointed_step, - idx[:, i * self.ctx_len:(i + 1) * self.ctx_len], - targets[:, i * self.ctx_len:(i + 1) * self.ctx_len], - seq_mask[:, i * self.ctx_len:(i + 1) * self.ctx_len], - total_loss, - states.shift_states, - states.wkv_states, - steps, - ) + segment_count = math.ceil(T / self.ctx_len) + + # + # TBPTT learning, we split the sequence into segments + # and perform a backward pass for each segment, on its own. + # + # Allowing us to perform backpropagation across context sizes much larger + # then what is supported by the current GPU memory. + # + # This reduces the need for the checkpointing process, and mitigate + # a known error where multiple backwards pass throws an exception. + # + # While not mathematically equivalent to full context size learning, + # it makes "infctx" size training possible with deepspeed 2/3 + # + # --- + # + # See the following, for more details on "Gradient computed twice" error: + # https://github.com/microsoft/DeepSpeed/issues/988#issuecomment-1549417269 + # + # Other possibly related issues on the topic: + # https://github.com/microsoft/DeepSpeed/pull/677 + # https://github.com/EleutherAI/gpt-neox/issues/62#issuecomment-766366413 + # + if do_bptt_learning: + + # Get the optimizer + optimizer = self.optimizers() + + # We get the average segment size, instead of ctx length size. + # this helps ensure that the segment cutoffs do not make the last segment too small, + # it also helps ensure the segment cutoff points are more varied, across mixed dataset sizes + # to avoid potentially undesired training behaviour at fixed cutoff points + # (this only applies for segmented learning) + segment_size = min(math.ceil(T / segment_count), self.ctx_len) + + # Segmented learning range + if self.bptt_learning_range > 0: + first_learning_segment = segment_count - self.bptt_learning_range; else: - total_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( - idx[:, i * self.ctx_len:(i + 1) * self.ctx_len], - targets[:, i * self.ctx_len:(i + 1) * self.ctx_len], - seq_mask[:, i * self.ctx_len:(i + 1) * self.ctx_len], - total_loss, - states.shift_states, - states.wkv_states, + first_learning_segment = 0; + + for i in range(segment_count): + # Apply state truncation, if truncated learning is enabled + if self.bptt_truncated_learning: + prv_shift_states = states.shift_states.clone().detach().requires_grad_(False) + prv_wkv_states = states.wkv_states.clone().detach().requires_grad_(False) + else: + prv_shift_states = states.shift_states + prv_wkv_states = states.wkv_states + + # Segmented learning, applies the forward/pass over each chunk seperately + segment_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( + idx[:, i * segment_size:(i + 1) * segment_size], + targets[:, i * segment_size:(i + 1) * segment_size], + seq_mask[:, i * segment_size:(i + 1) * segment_size], + torch.tensor(0, dtype=self.emb.weight.dtype).requires_grad_(True), + prv_shift_states, + prv_wkv_states, steps, ) - states = BlockStateList(new_shift_states, new_wkv_states) - gc.collect() - # torch.cuda.empty_cache() + states = BlockStateList(new_shift_states, new_wkv_states) + + # Compute the backward pass for the segment + if i >= first_learning_segment: + if i == segment_count-1: + # This is the last pass, we can drop the graph after this + self.manual_backward(segment_loss, optimizer) + else: + # Undocumented multiple backward pass support + # https://discord.com/channels/992359628979568762/1123248764132524242/1125374974597795920 + self.manual_backward(segment_loss, optimizer, retain_graph=True) + + # Accumulate the total loss, since there is nothing to backprop here + # its respective "backward pass" should be a no-op + total_loss = total_loss + segment_loss.clone().detach().requires_grad_(False) + + # GC collect unused memory + gc.collect() + # torch.cuda.empty_cache() + else: + + # Normal operations without TBPTT + segment_size = self.ctx_len + for i in range(segment_count): + if i < segment_count-1: + total_loss, new_shift_states, new_wkv_states, steps = deepspeed.checkpointing.checkpoint( + checkpointed_step, + idx[:, i * segment_size:(i + 1) * segment_size], + targets[:, i * segment_size:(i + 1) * segment_size], + seq_mask[:, i * segment_size:(i + 1) * segment_size], + total_loss, + states.shift_states, + states.wkv_states, + steps, + ) + else: + total_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( + idx[:, i * segment_size:(i + 1) * segment_size], + targets[:, i * segment_size:(i + 1) * segment_size], + seq_mask[:, i * segment_size:(i + 1) * segment_size], + total_loss, + states.shift_states, + states.wkv_states, + steps, + ) + + states = BlockStateList(new_shift_states, new_wkv_states) + gc.collect() + # torch.cuda.empty_cache() # Wandb logging only, if an active run exists if wandb.run is not None: @@ -615,6 +759,14 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, def training_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, True) self.log('train/loss', total_loss, prog_bar=True) + + # # The following barrier is required to syncronize the trainig step across all GPUs before + # # the optimizer step is performed for each batch. Otherwise a "hanged state" can occur. + # # + # # This is suppose to help with multi-gpu training (did not work) + # if (batch_idx + 1) % self.trainer.accumulate_grad_batches == 0: + # self.trainer.getFabric().barrier() + return total_loss def validation_step(self, batch, batch_idx): From 43821f6b35c0c7d095f325c1caa2cd5072e34f64 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Tue, 4 Jul 2023 12:55:23 +0000 Subject: [PATCH 05/57] Added example bptt_learning config --- RWKV-v4neo/config-example.yaml | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/RWKV-v4neo/config-example.yaml b/RWKV-v4neo/config-example.yaml index 064e180c..0f5db9e9 100644 --- a/RWKV-v4neo/config-example.yaml +++ b/RWKV-v4neo/config-example.yaml @@ -2,8 +2,9 @@ seed_everything: true trainer: # Configure the number of GPU, avaliable on your machine + # auto means it will automatically detect and use all GPUs accelerator: gpu - devices: 1 + devices: auto num_nodes: 1 # @@ -24,8 +25,7 @@ trainer: # For more details see: # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 # - #!FIXME: currently only deepspeed_stage_1 is supported, due to that deepspeed cannot handle repeated backward hook. - strategy: deepspeed_stage_1 + strategy: deepspeed_stage_2_offload # Floating point precision for the model, because RWKV is built FOR bf16 # you should pretty much never change this setting @@ -214,6 +214,26 @@ model: torch_set_float32_matmul_precision: 'high' # torch_set_float32_matmul_precision: null + # Back Propagation through time, used to work around training of large context length + # beyond what can be supported by the current GPU vram architecture + # + # This is not 1:1 equivalent to the same training process with the full vram + # as the training process is split into multiple segments, part by part. + # with limited learnings from the each segment. + bptt_learning: true + + # Segmented range to performing backprop learning on + # 1 means to apply only for the last segment + # -1 means to apply for all segments + bptt_learning_range: -1 + + # Limits the bptt learning only to the "current" chunk + # being learned within the learning range. While this reduces the effectiveness + # of bptt, it also further reduces vram requirements. + # + # This is also known as tbptt (Truncated Back Propagation through time) + bptt_truncated_learning: false + # various other settings you probably should leave alone grad_cp: true warmup_steps: -1 From 086dca4fd2df2dd336e5ef2491d8920e49a17b2d Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Tue, 4 Jul 2023 12:57:21 +0000 Subject: [PATCH 06/57] Clarified bptt_learning_range for multi-gpu setup --- RWKV-v4neo/config-example.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/RWKV-v4neo/config-example.yaml b/RWKV-v4neo/config-example.yaml index 0f5db9e9..8904ecef 100644 --- a/RWKV-v4neo/config-example.yaml +++ b/RWKV-v4neo/config-example.yaml @@ -225,6 +225,9 @@ model: # Segmented range to performing backprop learning on # 1 means to apply only for the last segment # -1 means to apply for all segments + # + # For multi-gpu training, this must be set to 1, due to a known issue + # else an exception would be thrown bptt_learning_range: -1 # Limits the bptt learning only to the "current" chunk From 7de40cb08c8d76a33e8d63d7c026f748536f9dd2 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Tue, 4 Jul 2023 16:31:38 +0000 Subject: [PATCH 07/57] reorder for readability --- RWKV-v4neo/src/model.py | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 16ff9a7c..1480fb8c 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -661,6 +661,9 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # Get the optimizer optimizer = self.optimizers() + + # Get the gradient accumulation steps size + gradient_accumulation_steps = max(1, self.trainer.accumulate_grad_batches) # We get the average segment size, instead of ctx length size. # this helps ensure that the segment cutoffs do not make the last segment too small, @@ -698,13 +701,17 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # Compute the backward pass for the segment if i >= first_learning_segment: - if i == segment_count-1: - # This is the last pass, we can drop the graph after this - self.manual_backward(segment_loss, optimizer) - else: + # The learning loss, should be normalized against the accumulation steps + learning_loss = segment_loss / gradient_accumulation_steps + + # Perform the backward pass accordingly + if i < segment_count-1: # Undocumented multiple backward pass support # https://discord.com/channels/992359628979568762/1123248764132524242/1125374974597795920 - self.manual_backward(segment_loss, optimizer, retain_graph=True) + self.manual_backward(learning_loss, optimizer, retain_graph=True) + else: + # This is the last pass, we can drop the graph after this + self.manual_backward(learning_loss, optimizer) # Accumulate the total loss, since there is nothing to backprop here # its respective "backward pass" should be a no-op From de2b570da2e0c886533c2b09fd1f44f77282ed77 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Tue, 4 Jul 2023 16:59:14 +0000 Subject: [PATCH 08/57] Fixing links --- RWKV-v4neo/src/model.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 1480fb8c..6c6eb44d 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -664,6 +664,9 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # Get the gradient accumulation steps size gradient_accumulation_steps = max(1, self.trainer.accumulate_grad_batches) + + # Get the current device + cur_device = self.device # We get the average segment size, instead of ctx length size. # this helps ensure that the segment cutoffs do not make the last segment too small, @@ -692,7 +695,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, idx[:, i * segment_size:(i + 1) * segment_size], targets[:, i * segment_size:(i + 1) * segment_size], seq_mask[:, i * segment_size:(i + 1) * segment_size], - torch.tensor(0, dtype=self.emb.weight.dtype).requires_grad_(True), + torch.tensor(0, dtype=self.emb.weight.dtype, device=cur_device).requires_grad_(True), prv_shift_states, prv_wkv_states, steps, @@ -702,12 +705,14 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # Compute the backward pass for the segment if i >= first_learning_segment: # The learning loss, should be normalized against the accumulation steps + # as we are bypassing the pytorch lightning normalization + # https://lightning.ai/docs/pytorch/2.0.4/common/lightning_module.html#backward learning_loss = segment_loss / gradient_accumulation_steps # Perform the backward pass accordingly if i < segment_count-1: # Undocumented multiple backward pass support - # https://discord.com/channels/992359628979568762/1123248764132524242/1125374974597795920 + # https://github.com/Lightning-AI/lightning/blob/678f642808c54e4c490caee4df5d357301c976bb/tests/trainer/optimization/test_manual_optimization.py#L251 self.manual_backward(learning_loss, optimizer, retain_graph=True) else: # This is the last pass, we can drop the graph after this From f9830dfe6294e9674d215bf93dfc2383dc277d87 Mon Sep 17 00:00:00 2001 From: Eugene Cheah Date: Wed, 5 Jul 2023 14:35:47 +0800 Subject: [PATCH 09/57] Update model.py last line whitespace change (force GH merge conflict to revaluate) From fa885f089384959d54a2c8fd4c5226671e8fdb54 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Wed, 5 Jul 2023 09:32:43 +0000 Subject: [PATCH 10/57] multi-gpu support doen by syncing up the exact same set of manual_backward calls --- RWKV-v4neo/src/model.py | 73 ++++++++++++++++++++++++++++------------- 1 file changed, 51 insertions(+), 22 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 6d0005c0..fdeb97fa 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -324,9 +324,6 @@ def configure_optimizers(self): if self.bptt_learning == False: if self.deepspeed_stage >= 2 or self.deepspeed_offload: print("[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length ({self.ctx_len})") - else: - if self.trainer.num_devices > 1 and (self.bptt_learning_range <= -1 or self.bptt_learning_range > 1): - raise NotImplementedError("bptt_learning_range must be limited to 1 in multi-gpu training, due to existing issues where `backprop(retain_graph=True)` where it hangs in multi-gpu training") if self.layerwise_lr: lr_1x = set() lr_2x = set() @@ -544,7 +541,7 @@ def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, # # This allow us to avoid disabling the "automatic_optimization" flag # - # Which would have been required to do "segmented learning", or "Truncated Backpropagation Through Time" + # Which would have been required to do "segmented learning", or "Backpropagation Through Time" # where we would need to implement manual optimization as per # https://lightning.ai/docs/pytorch/stable/model/manual_optimization.html # @@ -638,7 +635,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, segment_count = math.ceil(T / self.ctx_len) # - # TBPTT learning, we split the sequence into segments + # BPTT learning, we split the sequence into segments # and perform a backward pass for each segment, on its own. # # Allowing us to perform backpropagation across context sizes much larger @@ -661,30 +658,51 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # if do_bptt_learning: - # Get the optimizer - optimizer = self.optimizers() - - # Get the gradient accumulation steps size gradient_accumulation_steps = max(1, self.trainer.accumulate_grad_batches) - - # Get the current device + optimizer = self.optimizers() cur_device = self.device - # We get the average segment size, instead of ctx length size. - # this helps ensure that the segment cutoffs do not make the last segment too small, + # We use the average segment size, instead of ctx length size. + # this helps ensure that the segment cutoffs do not make the last segment too small. + # (eg, the last chunk having only 1 token) + # # it also helps ensure the segment cutoff points are more varied, across mixed dataset sizes - # to avoid potentially undesired training behaviour at fixed cutoff points + # and avoid potentially undesired training behaviour at fixed cutoff points # (this only applies for segmented learning) segment_size = min(math.ceil(T / segment_count), self.ctx_len) - # Segmented learning range + # We compute when we start the segmented learning process if self.bptt_learning_range > 0: first_learning_segment = segment_count - self.bptt_learning_range; else: first_learning_segment = 0; - for i in range(segment_count): + # Dummy 2D tenros of shape [1,1], are used to do "dummy checkpoint/forward/backprop" to keep everything in sync + dummy_2d_zero = torch.tensor([[0]], dtype=torch.long, device=cur_device) + + # Get the max segment count across all GPUs, in the current batch, which is used to keep all devices are in sync + # Once a thread has completed all its segments, it will do dummy checkpoint/forward/backprop with one token, + # and stay in sync with the thread that are still working on their segments + # + # This is used to work around an undocumented behaviour for either lightning / deepspeed loss.backward multi-gpu handling + # where the `self.manual_backward()` / `loss.backward()` call will block / freeze / hang when being too "out of sync" + # + # This can be viewed as a form of `fabric.barrier()` which is invoked implicitly by each `self.manual_backward()` call + # except that it isn't exactly a `fabric.barrier()` - because it does not block immediately and instead blocks in + # the next `self.manual_backward()` call if the previous ones are too far out of sync. + # (its confusing, but makes sense for efficency) + # + # Additionally because the "code line position" and params actually matter for the 'barrier' code effect, + # we cant work around this issue by doing dummy `self.manual_backward()` calls, in another if/else branch or loop + # + # Combined, this makes this issue very hard to trace and debug, as it will manifest itself as randomly "freezing" + # when out of sync during `self.manual_backward()` calls. Without the current work around put in place + shared_segment_count = self.trainer.getFabric().all_reduce(segment_count, reduce_op="max").item() + + for i in range(shared_segment_count): # Apply state truncation, if truncated learning is enabled + # this limits the backprop process, reduces loss learning rate, + # but save vram across extreamly large backpropagation steps if self.bptt_truncated_learning: prv_shift_states = states.shift_states.clone().detach().requires_grad_(False) prv_wkv_states = states.wkv_states.clone().detach().requires_grad_(False) @@ -692,11 +710,22 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, prv_shift_states = states.shift_states prv_wkv_states = states.wkv_states + # We use a dummy masked token 0, to do additional dummy checkpoint/forward/backprop when needed + # for each additional call after the current "segment_count" max + if i < segment_count - 1: + cur_idx = idx[:, i * segment_size:(i + 1) * segment_size] + cur_tar = targets[:, i * segment_size:(i + 1) * segment_size] + cur_msk = seq_mask[:, i * segment_size:(i + 1) * segment_size] + else: + cur_idx = dummy_2d_zero + cur_tar = dummy_2d_zero + cur_msk = dummy_2d_zero + # Segmented learning, applies the forward/pass over each chunk seperately segment_loss, new_shift_states, new_wkv_states, steps = checkpointed_step( - idx[:, i * segment_size:(i + 1) * segment_size], - targets[:, i * segment_size:(i + 1) * segment_size], - seq_mask[:, i * segment_size:(i + 1) * segment_size], + cur_idx, + cur_tar, + cur_msk, torch.tensor(0, dtype=self.emb.weight.dtype, device=cur_device).requires_grad_(True), prv_shift_states, prv_wkv_states, @@ -712,7 +741,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, learning_loss = segment_loss / gradient_accumulation_steps # Perform the backward pass accordingly - if i < segment_count-1: + if i < shared_segment_count-1: # Undocumented multiple backward pass support # https://github.com/Lightning-AI/lightning/blob/678f642808c54e4c490caee4df5d357301c976bb/tests/trainer/optimization/test_manual_optimization.py#L251 self.manual_backward(learning_loss, optimizer, retain_graph=True) @@ -721,7 +750,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, self.manual_backward(learning_loss, optimizer) # Accumulate the total loss, since there is nothing to backprop here - # its respective "backward pass" should be a no-op + # its final respective "backward pass" should be a no-op total_loss = total_loss + segment_loss.clone().detach().requires_grad_(False) # GC collect unused memory @@ -729,7 +758,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # torch.cuda.empty_cache() else: - # Normal operations without TBPTT + # Normal operations without BPTT segment_size = self.ctx_len for i in range(segment_count): if i < segment_count-1: From 6365ac6152329fd4b3ee4f8ba53260f6e4d9164a Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Wed, 5 Jul 2023 09:37:39 +0000 Subject: [PATCH 11/57] Fixed the import to `import gc, math` --- RWKV-v4neo/src/model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index fdeb97fa..6e01bfdb 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -2,7 +2,7 @@ # The RWKV Language Model - https://github.com/BlinkDL/RWKV-LM ######################################################################################################## -import os, math, sys +import gc, math from random import randint from typing import List, Optional From 450292360c8770a94cdd5d95685967cbc6a8a681 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Wed, 5 Jul 2023 11:06:01 +0000 Subject: [PATCH 12/57] Added fabric sync skip, if optimal conditions are met --- RWKV-v4neo/src/model.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 6e01bfdb..ec664952 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -324,6 +324,9 @@ def configure_optimizers(self): if self.bptt_learning == False: if self.deepspeed_stage >= 2 or self.deepspeed_offload: print("[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length ({self.ctx_len})") + else: + if self.trainer.num_devices > 1 and (self.bptt_learning_range <= 0 or self.bptt_learning_range > 1): + print("[WARNING]: bptt_learning with learning_range > 1 across multiple GPU's has a major performance penalty with datasets of mixed sizes due to its constant need to keep all GPU's in sync") if self.layerwise_lr: lr_1x = set() lr_2x = set() @@ -697,7 +700,13 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # # Combined, this makes this issue very hard to trace and debug, as it will manifest itself as randomly "freezing" # when out of sync during `self.manual_backward()` calls. Without the current work around put in place - shared_segment_count = self.trainer.getFabric().all_reduce(segment_count, reduce_op="max").item() + # + # We only do this, if we are doing bptt learning on more then 1 segment, and gpu count > 1 + # otherwise we just use the segment count as it is + if self.trainer.num_devices > 1 and (self.bptt_learning_range > 1 or self.bptt_learning_range <= 0): + shared_segment_count = self.trainer.getFabric().all_reduce(segment_count, reduce_op="max").item() + else: + shared_segment_count = segment_count for i in range(shared_segment_count): # Apply state truncation, if truncated learning is enabled From d9945f08936785cb94101d1f6e771e9ca841901f Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Wed, 5 Jul 2023 11:17:30 +0000 Subject: [PATCH 13/57] Fixed error messages for bptt_learning_range > 1, which can hang with a mixed dataset size --- RWKV-v4neo/src/model.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index ec664952..1214532e 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -325,8 +325,13 @@ def configure_optimizers(self): if self.deepspeed_stage >= 2 or self.deepspeed_offload: print("[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length ({self.ctx_len})") else: - if self.trainer.num_devices > 1 and (self.bptt_learning_range <= 0 or self.bptt_learning_range > 1): - print("[WARNING]: bptt_learning with learning_range > 1 across multiple GPU's has a major performance penalty with datasets of mixed sizes due to its constant need to keep all GPU's in sync") + if self.trainer.num_devices > 1: + if self.bptt_learning_range <= 0: + print("[WARNING]: unlimited bptt_learning_range across multiple GPU's has a major performance penalty with datasets of mixed sizes due to its constant need to keep all GPU's in sync (consider using bptt_learning_range=1 instead)") + if self.bptt_learning_range > 1: + # Temporary error, till better sync logic is done for mixed document sizes + # (lazy to support this right now, since i have no idea if anyone has a use for it) + raise NotImplementedError("bptt_learning_range > 1 is not supported yet") if self.layerwise_lr: lr_1x = set() lr_2x = set() From a879e9cca0900c05f4f15b95cdd099ef2d45be29 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Wed, 5 Jul 2023 13:14:30 +0000 Subject: [PATCH 14/57] tweaks to reduce the number of backward pass by 1 --- RWKV-v4neo/src/model.py | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 1214532e..3c425989 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -759,13 +759,13 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # Undocumented multiple backward pass support # https://github.com/Lightning-AI/lightning/blob/678f642808c54e4c490caee4df5d357301c976bb/tests/trainer/optimization/test_manual_optimization.py#L251 self.manual_backward(learning_loss, optimizer, retain_graph=True) + + # Accumulate without gradient, as we already did the backward pass + total_loss = total_loss + segment_loss.clone().detach().requires_grad_(False) else: - # This is the last pass, we can drop the graph after this - self.manual_backward(learning_loss, optimizer) - - # Accumulate the total loss, since there is nothing to backprop here - # its final respective "backward pass" should be a no-op - total_loss = total_loss + segment_loss.clone().detach().requires_grad_(False) + # This is the last pass, we let the default pytorch lightning handle the backward pass + # and return the segment loss as part of the total loss + total_loss = total_loss + segment_loss # GC collect unused memory gc.collect() @@ -817,13 +817,6 @@ def training_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, True) self.log('train/loss', total_loss, prog_bar=True) - # # The following barrier is required to syncronize the trainig step across all GPUs before - # # the optimizer step is performed for each batch. Otherwise a "hanged state" can occur. - # # - # # This is suppose to help with multi-gpu training (did not work) - # if (batch_idx + 1) % self.trainer.accumulate_grad_batches == 0: - # self.trainer.getFabric().barrier() - return total_loss def validation_step(self, batch, batch_idx): From c5de65a57d9419d2a01e7aaf3b52bf935dd76d77 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Thu, 6 Jul 2023 02:51:12 +0000 Subject: [PATCH 15/57] Fixed loss calculation for multiple segment + multi gpu --- RWKV-v4neo/src/model.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 3c425989..e08877cb 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -327,7 +327,7 @@ def configure_optimizers(self): else: if self.trainer.num_devices > 1: if self.bptt_learning_range <= 0: - print("[WARNING]: unlimited bptt_learning_range across multiple GPU's has a major performance penalty with datasets of mixed sizes due to its constant need to keep all GPU's in sync (consider using bptt_learning_range=1 instead)") + print("[WARNING]: unlimited bptt_learning_range across multiple GPU's has a performance penalty with datasets of mixed sizes due to its constant need to keep all GPU's in sync (consider using bptt_learning_range=1 instead)") if self.bptt_learning_range > 1: # Temporary error, till better sync logic is done for mixed document sizes # (lazy to support this right now, since i have no idea if anyone has a use for it) @@ -713,6 +713,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, else: shared_segment_count = segment_count + # Lets go through all the segments (including dummy ones) for i in range(shared_segment_count): # Apply state truncation, if truncated learning is enabled # this limits the backprop process, reduces loss learning rate, @@ -726,7 +727,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # We use a dummy masked token 0, to do additional dummy checkpoint/forward/backprop when needed # for each additional call after the current "segment_count" max - if i < segment_count - 1: + if i <= segment_count - 1: cur_idx = idx[:, i * segment_size:(i + 1) * segment_size] cur_tar = targets[:, i * segment_size:(i + 1) * segment_size] cur_msk = seq_mask[:, i * segment_size:(i + 1) * segment_size] @@ -766,6 +767,9 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # This is the last pass, we let the default pytorch lightning handle the backward pass # and return the segment loss as part of the total loss total_loss = total_loss + segment_loss + else: + # Even if its not the segments we use for backward pass, we need to accumulate the loss + total_loss = total_loss + segment_loss.clone().detach().requires_grad_(False) # GC collect unused memory gc.collect() From 221cc86b9b1721f71b871a0daaf8288926d7afd1 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Thu, 6 Jul 2023 03:27:23 +0000 Subject: [PATCH 16/57] better wandb logging across multiple GPUs --- RWKV-v4neo/src/model.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index e08877cb..d4b23c25 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -807,8 +807,12 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, # Wandb logging only, if an active run exists if wandb.run is not None: + global_rank = self.global_rank + global_device_count = self.trainer.num_devices * self.trainer.num_nodes wandb.log({ - 'substep': batch_idx, + 'substep': batch_idx * global_device_count + global_rank, + 'batchidx': batch_idx, + 'global_rank': global_rank, 'real_ctx_len': T, 'train/loss': total_loss, 'trainer/global_step':self.global_step, From 3122f0a5278cbe3a305238ab28a3347c15114027 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 07:42:43 +0000 Subject: [PATCH 17/57] disabled JIT --- RWKV-v4neo/src/model.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index d4b23c25..fd21182a 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -22,8 +22,7 @@ import deepspeed.runtime.lr_schedules import wandb -RWKV_JIT_ON = True - +RWKV_JIT_ON = False if RWKV_JIT_ON: MyModule = torch.jit.ScriptModule MyFunction = torch.jit.script_method From 00b8a1b17d502879a133d6a299e209840fb404d4 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 08:14:59 +0000 Subject: [PATCH 18/57] Setting up baseline notebook (reorganizing all notebooks) --- .../trainer-validation/baseline-setup.ipynb | 384 ++++++++++++++++++ .../trainer-validation/config-baseline.yaml | 339 ++++++++++++++++ .../trainer-validation/config-dryrun.yaml | 339 ++++++++++++++++ 3 files changed, 1062 insertions(+) create mode 100644 notebook/trainer-validation/baseline-setup.ipynb create mode 100644 notebook/trainer-validation/config-baseline.yaml create mode 100644 notebook/trainer-validation/config-dryrun.yaml diff --git a/notebook/trainer-validation/baseline-setup.ipynb b/notebook/trainer-validation/baseline-setup.ipynb new file mode 100644 index 00000000..123dd712 --- /dev/null +++ b/notebook/trainer-validation/baseline-setup.ipynb @@ -0,0 +1,384 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# InfCtx trainer validation\n", + "The trainer validation is mostly done using the same settings as raven 1B5 model.\n", + "- Layer count: 24\n", + "- Embed size: 2048\n", + "\n", + "Typically with the following dataset\n", + "- \"teven/enwiki_10k\" dataset, chunked to 1024 token sizes\n", + "\n", + "The following notebook, helps perform the basic download and setup for the \"init model\", and \"test dataset\". Which is used as a reference point for all other validation processes (unless stated otherwise)\n", + "\n", + "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps\n", + ">\n", + "> All training runs (except dryrun) is configured to log to weights and bias, comment out the logger in the config file if you want to avoid this" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preparing the init model and test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-07-07 05:57:18-- https://huggingface.co/picocreator/memory-size-experiment-for-rwkv/resolve/main/Echo-A-1B5-Init.pth\n", + "Resolving huggingface.co (huggingface.co)... 99.84.108.70, 99.84.108.129, 99.84.108.87, ...\n", + "Connecting to huggingface.co (huggingface.co)|99.84.108.70|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://cdn-lfs.huggingface.co/repos/cb/ef/cbef09abb2634a3375b28868bffa285226dfeabedec89b28c2fb302221164d66/0ec7214ed16737a6348254e6f96d8cdc04d3b5efbd5f53fe9337607ea42b5b9f?response-content-disposition=attachment%3B+filename*%3DUTF-8%27%27Echo-A-1B5-Init.pth%3B+filename%3D%22Echo-A-1B5-Init.pth%22%3B&Expires=1688968638&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTY4ODk2ODYzOH19LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5odWdnaW5nZmFjZS5jby9yZXBvcy9jYi9lZi9jYmVmMDlhYmIyNjM0YTMzNzViMjg4NjhiZmZhMjg1MjI2ZGZlYWJlZGVjODliMjhjMmZiMzAyMjIxMTY0ZDY2LzBlYzcyMTRlZDE2NzM3YTYzNDgyNTRlNmY5NmQ4Y2RjMDRkM2I1ZWZiZDVmNTNmZTkzMzc2MDdlYTQyYjViOWY%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qIn1dfQ__&Signature=bWrBilBq61eOdD083qL6gaRBmu%7EeHdIZkOP2qm1guITML%7EkcnGNm%7EIVwoiSEDp-3Of%7EVz065FtfY8-DcCgLNdfnZ%7Ew36hly5DW%7E8CzcSlQLRR%7EQnG9j-ubmOeCemqlyecAMC7l%7E1sVus3RbMCkSo%7E6%7Eq8H%7EvnTbrgqydZmN%7E-XJ8l8mxAMCOCBH1yHmd2cmLz8kO8JPush23Zn4gHqo2vXluzR%7EAKe3a5IxlqZGmG7JIlB8ghYc0DjtSXqh5oGTB11qWxmGhlwBA5x3xbdHL3d4CACpx6HlwsQzQ7MC4czwAQqCmwTnaq3gZBF7TvaQc%7EQNU8JKD-tSX3C8uaaWYiw__&Key-Pair-Id=KVTP0A1DKRTAX [following]\n", + "--2023-07-07 05:57:18-- https://cdn-lfs.huggingface.co/repos/cb/ef/cbef09abb2634a3375b28868bffa285226dfeabedec89b28c2fb302221164d66/0ec7214ed16737a6348254e6f96d8cdc04d3b5efbd5f53fe9337607ea42b5b9f?response-content-disposition=attachment%3B+filename*%3DUTF-8%27%27Echo-A-1B5-Init.pth%3B+filename%3D%22Echo-A-1B5-Init.pth%22%3B&Expires=1688968638&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTY4ODk2ODYzOH19LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5odWdnaW5nZmFjZS5jby9yZXBvcy9jYi9lZi9jYmVmMDlhYmIyNjM0YTMzNzViMjg4NjhiZmZhMjg1MjI2ZGZlYWJlZGVjODliMjhjMmZiMzAyMjIxMTY0ZDY2LzBlYzcyMTRlZDE2NzM3YTYzNDgyNTRlNmY5NmQ4Y2RjMDRkM2I1ZWZiZDVmNTNmZTkzMzc2MDdlYTQyYjViOWY%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qIn1dfQ__&Signature=bWrBilBq61eOdD083qL6gaRBmu%7EeHdIZkOP2qm1guITML%7EkcnGNm%7EIVwoiSEDp-3Of%7EVz065FtfY8-DcCgLNdfnZ%7Ew36hly5DW%7E8CzcSlQLRR%7EQnG9j-ubmOeCemqlyecAMC7l%7E1sVus3RbMCkSo%7E6%7Eq8H%7EvnTbrgqydZmN%7E-XJ8l8mxAMCOCBH1yHmd2cmLz8kO8JPush23Zn4gHqo2vXluzR%7EAKe3a5IxlqZGmG7JIlB8ghYc0DjtSXqh5oGTB11qWxmGhlwBA5x3xbdHL3d4CACpx6HlwsQzQ7MC4czwAQqCmwTnaq3gZBF7TvaQc%7EQNU8JKD-tSX3C8uaaWYiw__&Key-Pair-Id=KVTP0A1DKRTAX\n", + "Resolving cdn-lfs.huggingface.co (cdn-lfs.huggingface.co)... 108.138.64.49, 108.138.64.36, 108.138.64.121, ...\n", + "Connecting to cdn-lfs.huggingface.co (cdn-lfs.huggingface.co)|108.138.64.49|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 3030345861 (2.8G) [binary/octet-stream]\n", + "Saving to: ‘Echo-A-1B5-Init.pth’\n", + "\n", + "Echo-A-1B5-Init.pth 100%[===================>] 2.82G 60.9MB/s in 50s \n", + "\n", + "2023-07-07 05:58:09 (57.6 MB/s) - ‘Echo-A-1B5-Init.pth’ saved [3030345861/3030345861]\n", + "\n", + "-rw-rw-r-- 1 ubuntu ubuntu 2.9G Jun 22 04:41 ../../model/Echo-A-1B5-Init.pth\n" + ] + } + ], + "source": [ + "# First lets setup the various directories, and get the blank init model, these init model was generated\n", + "# using the original RWKV-LM repo (as at this point of writing, this repo cannot init a model)\n", + "# As such I have preinitialized these blank models and uploaded them to HF for convinence\n", + "!mkdir -p ../../model/\n", + "!mkdir -p ../../datapath/\n", + "!mkdir -p ../../checkpoint/\n", + "!rm -rf ../../model/Echo-A-1B5-Init.pth\n", + "!cd ../../model/ && wget https://huggingface.co/picocreator/memory-size-experiment-for-rwkv/resolve/main/Echo-A-1B5-Init.pth\n", + "!ls -alh ../../model/Echo-A-1B5-Init.pth" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 986.66it/s]\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", + " \r" + ] + } + ], + "source": [ + "# Lets preload the requried dataset\n", + "!cd ../../RWKV-v4neo && python3 preload_dataset.py ../notebook/trainer-validation/baseline-run.yaml" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Trainer Code validation via dryrun\n", + "\n", + "The following dryrun, helps check that the existing trainer code changes are valid across 2 * 2 data samples.\n", + "It does not log the run the W&B" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting ds_accelerator to cuda (auto detect)\n", + "Global seed set to 3941088705\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_128_bf16/build.ninja...\n", + "Building extension module wkv_128_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "[1/3] /usr/local/cuda/bin/nvcc -DTORCH_EXTENSION_NAME=wkv_128_bf16 -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\\\"_gcc\\\" -DPYBIND11_STDLIB=\\\"_libstdcpp\\\" -DPYBIND11_BUILD_ABI=\\\"_cxxabi1011\\\" -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/TH -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr -gencode=arch=compute_86,code=compute_86 -gencode=arch=compute_86,code=sm_86 --compiler-options '-fPIC' -t 4 -std=c++17 -res-usage --maxrregcount 60 --use_fast_math -O3 -Xptxas -O3 --extra-device-vectorization -DTmax=128 -c /home/ubuntu/RWKV-LM-LoRA-merge/RWKV-v4neo/cuda/wkv_cuda_bf16.cu -o wkv_cuda_bf16.cuda.o \n", + "ptxas info : 1 bytes gmem\n", + "ptxas info : Compiling entry function '_Z15kernel_backwardiiiPKfPKN3c108BFloat16ES4_S4_S0_S4_S0_PS2_S5_S5_S5_Pf' for 'sm_86'\n", + "ptxas info : Function properties for _Z15kernel_backwardiiiPKfPKN3c108BFloat16ES4_S4_S0_S4_S0_PS2_S5_S5_S5_Pf\n", + " 1536 bytes stack frame, 0 bytes spill stores, 0 bytes spill loads\n", + "ptxas info : Used 56 registers, 464 bytes cmem[0], 8 bytes cmem[2]\n", + "ptxas info : Compiling entry function '_Z14kernel_forwardiiiPKfPKN3c108BFloat16ES4_S4_S0_PS2_Pf' for 'sm_86'\n", + "ptxas info : Function properties for _Z14kernel_forwardiiiPKfPKN3c108BFloat16ES4_S4_S0_PS2_Pf\n", + " 0 bytes stack frame, 0 bytes spill stores, 0 bytes spill loads\n", + "ptxas info : Used 40 registers, 424 bytes cmem[0]\n", + "[2/3] c++ -MMD -MF wkv_op_bf16.o.d -DTORCH_EXTENSION_NAME=wkv_128_bf16 -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\\\"_gcc\\\" -DPYBIND11_STDLIB=\\\"_libstdcpp\\\" -DPYBIND11_BUILD_ABI=\\\"_cxxabi1011\\\" -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/TH -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -fPIC -std=c++17 -std=c++17 -O3 -DTmax=128 -c /home/ubuntu/RWKV-LM-LoRA-merge/RWKV-v4neo/cuda/wkv_op_bf16.cpp -o wkv_op_bf16.o \n", + "[3/3] c++ wkv_op_bf16.o wkv_cuda_bf16.cuda.o -shared -L/home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/lib -lc10 -lc10_cuda -ltorch_cpu -ltorch_cuda -ltorch -ltorch_python -L/usr/local/cuda/lib64 -lcudart -o wkv_128_bf16.so\n", + "Loading extension module wkv_128_bf16...\n", + "/home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", + " warning_cache.warn(\n", + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 970.45it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec/cache-08de1ca402bb082a_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec/cache-a1f76c32471ce85a_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec/cache-2fdd1d8e3fc93ac5_*_of_00032.arrow\n", + "[rank: 0] Global seed set to 3941088705 \n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[2023-07-07 08:01:07,186] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-07 08:01:07,187] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "Enabling DeepSpeed BF16.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module cpu_adam...\n", + "Time to load cpu_adam op: 2.3342714309692383 seconds\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/utils/build.ninja...\n", + "Building extension module utils...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module utils...\n", + "Time to load utils op: 0.060671091079711914 seconds\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "No modifications detected for re-loaded extension module utils, skipping build step...\n", + "Loading extension module utils...\n", + "Time to load utils op: 0.00025725364685058594 seconds\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "Epoch 0: 0%| | 1/5308 [00:09<13:51:55, 9.41s/it, v_num=0, train/loss=11.00]" + ] + } + ], + "source": [ + "# Validate source code and env is working, by doing a short 2 sample dryrun\n", + "!cd ../../RWKV-v4neo && python3 new_train.py fit -c ../notebook/trainer-validation/config-dryrun.yaml" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Baseline full context (1024) training\n", + "\n", + "Perform a full 1 epoch training run of training context size = 1024. Ensuring all data samples fit within the allocated training size. And is used as the baseline loss comparision for several experiments" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-07-01 20:53:18,310] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "Global seed set to 3941088705\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mpicocreator\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.4\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230701_205320-k8flu72z\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-validation-full (train-ctx=1024, data-ctx=1024, bs=12)\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/k8flu72z\u001b[0m\n", + "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/wkv_1024_bf16/build.ninja...\n", + "Building extension module wkv_1024_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module wkv_1024_bf16...\n", + "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 675.41it/s]\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", + "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "[rank: 0] Global seed set to 3941088705\n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[2023-07-01 20:53:34,204] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "Enabling DeepSpeed BF16.\n", + "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/pytorch/callbacks/model_checkpoint.py:615: UserWarning: Checkpoint directory /home/picocreator/rwkv-proj/infctx-dev/checkpoint/trainer-validaiton/infctx-validation-full exists and is not empty.\n", + " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\u001b[93m [WARNING] \u001b[0m cpu_adam cuda is missing or is incompatible with installed torch, only cpu ops can be compiled!\n", + "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", + "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module cpu_adam...\n", + "Time to load cpu_adam op: 2.312431812286377 seconds\n", + "Loading `train_dataloader` to estimate number of stepping batches.\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "Epoch 0: 100%|█| 5318/5318 [51:02<00:00, 1.74it/s, v_num=u72z, train/loss=5.940\n", + "Validation: 0it [00:00, ?it/s]\u001b[A\n", + "Validation: 0%| | 0/54 [00:00` script, + # which will create a `rwkv_model.pth` in the checkpoint directory. + # + # Do not use the `zero_to_fp32.py` script as that will have export format issues + dirpath: ../checkpoint/trainer-validaiton/infctx-validation-baseline + filename: null + + # Save the top/last K checkpoints + save_top_k: 3 + # Choose by the most recent checkpoints (step based) + monitor: 'step' + mode: max + + # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' + # useful to simply checkpoint resume scripts, at a price of disk performance + save_last: false + + # DO NOT set this as true, as the model weight exported will have format issues + # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead + save_weights_only: false + + # How frequent you want to save a checkpoint for every step. + # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches + # + # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) + # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process + # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes + every_n_train_steps: 5000 + every_n_epochs: null + save_on_train_epoch_end: true + train_time_interval: null + + # Other settings, you can probably leave alone + verbose: false + auto_insert_metric_name: true + + ######################################## + ## Training run parameter settings + ######################################## + + # Generally what you want to configure is the maximum number of epochs + # Leave it as -1, and it will keep going forever till interrupted + # Or set it as a number, and it will stop after that number of epochs + max_epochs: 1 + min_epochs: null + max_steps: -1 + min_steps: null + max_time: null + + # Number of datasamples to train for each step, a data sample is considered + # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" + # + # This decides the number of datasample, to learn together from, before backproping + # any weight changes at the end of the batch. + # + # Recommended to be a big enough number (like 128/256) where it prevents the training + # loss from flucuating in the process. But not too big of a number where the increased + # GPU vRAM / offloaded RAM usage will cause the training to crash. + # + # You are also recommended to configure this to a large enough number to fully utilize + # your GPU processing time %, and avoid idle time for the GPU between batches + accumulate_grad_batches: 12 + + # Various other settings, you probably want to leave alone + fast_dev_run: false + limit_train_batches: null + limit_val_batches: null + limit_test_batches: null + limit_predict_batches: null + overfit_batches: 0.0 + val_check_interval: null + check_val_every_n_epoch: 1 + num_sanity_val_steps: 0 + log_every_n_steps: 1 + enable_checkpointing: true + enable_progress_bar: null + enable_model_summary: null + gradient_clip_val: 1.0 + gradient_clip_algorithm: null + deterministic: null + benchmark: null + inference_mode: true + use_distributed_sampler: true + profiler: null + detect_anomaly: false + barebones: false + plugins: null + sync_batchnorm: false + reload_dataloaders_every_n_epochs: 0 + default_root_dir: null + +######################################## +## Training model settings +######################################## +model: + # Model to start the finetune/training process from + load_model: ../model/Echo-A-1B5-Init.pth + + # The model size setting, this MUST match + # your current model settings, refer to the model card + # of the downloaded model for more details + n_embd: 2048 + n_layer: 24 + vocab_size: 50277 + + # Context length to use for the training process + # the larger the number (and batch size) the larger the vram usage + # + # Note that if the datasample context length is larger then the ctx_len + # its training process would be split into ctx_len sized chunks. + # + # This allows the training of extreamly large context length (eg. 100k), + # without eating up too much vram by keeping the training context length + # to a resonable number sutible to the current GPU setup + ctx_len: 1024 + + # Data samples would be cut down to the respective max ctx_len_cutoffs + # values if its larger then ctx_len. If the data sample is larger then + # the largest len_cutoff, the remaining data will be discarded + ctx_len_cutoffs: [1024, 2048, 4096, 8192, 16384, 32768, 65536] + # Experimental settings, number of tokens to skip in the data sample + # prefix, for the respective cutoff length. Used to speed up the process + ctx_len_warmup_steps: [0, 0, 0, 0, 0, 0, 0] + + # Learning rate of the training process + # --- + # Initia learning rate of the process + lr_init: 6e-4 + # Final learning rate after the learning rate period + # learning rate will stay at final value from then onwards + # + # NOTE: lr_final / lr_period does not work with warmup_steps + # and will be ignored (or replaced) with the warmup_steps logic instead + lr_final: 4e-4 + # Number of epoch to reduce the learning rate from lr_init to lr_final + # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) + # 0 means lr_final will apply immediately + # -1 means we take the current max_step / max_epoch as the period + lr_period: 1 + # lr_period type if its set, defaults to epoch + lr_period_type: epoch + + # Adam optimizer settings + # You probably want to leave this alone, unless you know what you are doing + beta1: 0.9 + beta2: 0.99 + adam_eps: 1.0e-08 + weight_decay: 0.01 + + # torch.set_float32_matmul_precision, used to optimize operations with tensor cores + # this should be set as null, for non cuda core GPUs + torch_set_float32_matmul_precision: 'high' + # torch_set_float32_matmul_precision: null + + # Segmented based learning, used to work around training of large context length + # beyond what can be supported by the current GPU vram architecture + # + # This is not 1:1 equivalent to the same training process with required vram + # as the training process is split into multiple segments, part by part. + # with limited learnings from the previous segment. + bptt_learning: false + + # Segmented range to performing backprop learning on + # 1 means to apply only for the last segment + # -1 means to apply for all segments + bptt_learning_range: -1 + + # various other settings you probably should leave alone + grad_cp: true + warmup_steps: -1 + layerwise_lr: true + dim_att: null + dim_ffn: null +data: + # dataset_path for the prebuilt dataset, using HF `load_from_disk()` + # + # Use this if you have built your own dataset and saved it with `save_to_disk()` + # with source left as null. Other wise configure this to a directory which the + # dataset will be built and tokenized by the huggingface dataset process. + data_path: ../datapath/enwiki_10k_1024/ + + # Other wise provide the source path, which is used as huggingface dataset path + # this will be used to populate the dataset_path + # + # Use either the following + # - hugging face dataset + # - Directory path to a directory containing dataset files + # - Path to a single dataset file + # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) + # - null + # + # If source is disabled, all other params, except data_path, is ignored + source: "teven/enwiki_10k" + # source: text + # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt + + # Use data_dir, if you are using source=text/json/etc + # this should be relative to the data_path + source_data_dir: null + + # After loading the dataset, split out test data used for validation, + # This process is skipped if the dataset includes a test split + # This process is skipped if set to zero + test_split: 0.01 + test_split_shuffle: false + + # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer + # If using a custom tokenizer, provide the tokenizer file path + # --- + tokenizer: neox + + # Minimum / Maximum token size of the dataset to use + # useful for filtering out small noisy data samples from large datasets + # (eg. removal of small articles of less then 512 tokens from wikipedia) + # + # This is ignored, if set to -1 + min_token_size: 64 + max_token_size: -1 + + # Rechunking of text dataset, this is done only when source is set as 'text' + # and will merge the various sentencees, into larger chunks up to the target size + # + # Defaults to 4096 + # + # This is ignored, if source is not set as text + # This is ignored, if set to zero + # --- + text_rechunk_size: 1024 + + # Apply text rechunk to the dataset, even if its not a 'text' source + # This is done only after dataset filtering, and if source is not 'text' + # --- + text_rechunk_force: true + + # Custom text column to use, useful for dataset with alternative training columns labels + # This is checked before multi column merging, default is null (disabled) + # eg: 'code' + # --- + # custom_text_key: 'code' + + # Multi Column merging process, default setting is used to support and merge + # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] + # + # A minimum of 2 columns is required, with non empty data, for the merge to occur + # If no match is found, this will fallback to the default prompt/completion or text column, + # or throw an error if the default fallback is not found + # --- + # multi_column_keys: ['instruction', 'input', 'output'] + # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] + # multi_column_masking: [false, true, false] + # multi_column_seperator: '\n\n' + + # If processing prompt/completion jsonl pairs, the prompt is masked by default + # use this flag to disable this default behaviour + # --- + # disable_prompt_mask: false + +# Path to the current checkpoint to continue training from +# Enable this to the last checkpoint after the first run +# (if it crash and you want to resume) +# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-baseline/epoch=0-step=20.ckpt +ckpt_path: null diff --git a/notebook/trainer-validation/config-dryrun.yaml b/notebook/trainer-validation/config-dryrun.yaml new file mode 100644 index 00000000..4d4295c3 --- /dev/null +++ b/notebook/trainer-validation/config-dryrun.yaml @@ -0,0 +1,339 @@ +# lightning.pytorch==2.0.2 +seed_everything: 3941088705 +trainer: + # Configure the number of GPU, avaliable on your machine + accelerator: gpu + devices: auto + num_nodes: 1 + + # + # Configure the deepspeed strategy, we recommend you start with `deepspeed_stage_2_offload` + # and adjust from there according to your training needs. `deepspeed_stage_3_offload` is useful + # for training LoRA on large models on a single GPU. + # + # In general you would want to use the following: + # + # - deepspeed_stage_1 : Each of your GPU has too much vram, and you do not know what to do + # + # - deepspeed_stage_2 : Optimal distributed training strategy, across multiple gpu each with sufficient vram + # - deepspeed_stage_2_offload : Reduce vram usage by offloading the optimizer state and work to cpu + # + # - deepspeed_stage_3 : Split up the model across multiple gpu, useful for large models, at a performance cost + # - deepspeed_stage_3_offload : Additional offloading, for even greater performance cost + # + # For more details see: + # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 + # + strategy: deepspeed_stage_2_offload + + # Floating point precision for the model, because RWKV is built FOR bf16 + # you should pretty much never change this setting + precision: bf16 + + # Logger setting for wandb, if you want to enable wandb, uncomment the whole logger section + # --- + # logger: + # class_path: lightning.pytorch.loggers.WandbLogger + # init_args: + # name: 'infctx-validation-dryrun (short 2 * 2 data sample dry run)' + # project: 'RWKV-Memory-Experiment' + # tags: ['RWKV', 'memory-exp'] + # id: null + # save_dir: . + # version: null + # offline: false + # dir: null + # anonymous: null + # log_model: false + # experiment: null + # prefix: '' + # checkpoint_name: null + # job_type: null + # config: null + # entity: null + # reinit: null + # group: null + # notes: null + # magic: null + # config_exclude_keys: null + # config_include_keys: null + # mode: null + # allow_val_change: null + # resume: null + # force: null + # tensorboard: null + # sync_tensorboard: null + # monitor_gym: null + # save_code: null + # settings: null + + # Checkpoint settings for the training process + callbacks: + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + # Configure this to the path you want to save your checkpoints to + # note that a subdir will be created with the name `epoch=x-step=y.ckpt` + # + # to convert a checkpoint to a model, you can use the + # `python3 export_checkpoint.py ` script, + # which will create a `rwkv_model.pth` in the checkpoint directory. + # + # Do not use the `zero_to_fp32.py` script as that will have export format issues + dirpath: ../checkpoint/trainer-validaiton/infctx-validation-dryrun + filename: null + + # Save the top/last K checkpoints + save_top_k: 3 + # Choose by the most recent checkpoints (step based) + monitor: 'step' + mode: max + + # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' + # useful to simply checkpoint resume scripts, at a price of disk performance + save_last: false + + # DO NOT set this as true, as the model weight exported will have format issues + # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead + save_weights_only: false + + # How frequent you want to save a checkpoint for every step. + # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches + # + # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) + # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process + # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes + every_n_train_steps: 2500 + every_n_epochs: null + save_on_train_epoch_end: true + train_time_interval: null + + # Other settings, you can probably leave alone + verbose: false + auto_insert_metric_name: true + + ######################################## + ## Training run parameter settings + ######################################## + + # Generally what you want to configure is the maximum number of epochs + # Leave it as -1, and it will keep going forever till interrupted + # Or set it as a number, and it will stop after that number of epochs + max_epochs: -1 + min_epochs: null + max_steps: 2 + min_steps: null + max_time: null + + # Number of datasamples to train for each step, a data sample is considered + # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" + # + # This decides the number of datasample, to learn together from, before backproping + # any weight changes at the end of the batch. + # + # Recommended to be a big enough number (like 128/256) where it prevents the training + # loss from flucuating in the process. But not too big of a number where the increased + # GPU vRAM / offloaded RAM usage will cause the training to crash. + # + # You are also recommended to configure this to a large enough number to fully utilize + # your GPU processing time %, and avoid idle time for the GPU between batches + accumulate_grad_batches: 2 + + # Various other settings, you probably want to leave alone + fast_dev_run: false + limit_train_batches: null + limit_val_batches: null + limit_test_batches: null + limit_predict_batches: null + overfit_batches: 0.0 + val_check_interval: null + check_val_every_n_epoch: 1 + num_sanity_val_steps: 0 + log_every_n_steps: 1 + enable_checkpointing: true + enable_progress_bar: null + enable_model_summary: null + gradient_clip_val: 1.0 + gradient_clip_algorithm: null + deterministic: null + benchmark: null + inference_mode: true + use_distributed_sampler: true + profiler: null + detect_anomaly: false + barebones: false + plugins: null + sync_batchnorm: false + reload_dataloaders_every_n_epochs: 0 + default_root_dir: null + +######################################## +## Training model settings +######################################## +model: + # Model to start the finetune/training process from + load_model: ../model/Echo-A-1B5-Init.pth + + # The model size setting, this MUST match + # your current model settings, refer to the model card + # of the downloaded model for more details + n_embd: 2048 + n_layer: 24 + vocab_size: 50277 + + # Context length to use for the training process + # the larger the number (and batch size) the larger the vram usage + # + # Note that if the datasample context length is larger then the ctx_len + # its training process would be split into ctx_len sized chunks. + # + # This allows the training of extreamly large context length (eg. 100k), + # without eating up too much vram by keeping the training context length + # to a resonable number sutible to the current GPU setup + ctx_len: 128 + + # Data samples would be cut down to the respective max ctx_len_cutoffs + # values if its larger then ctx_len. If the data sample is larger then + # the largest len_cutoff, the remaining data will be discarded + ctx_len_cutoffs: [1024, 2048, 4096, 8192, 16384, 32768, 65536] + # Experimental settings, number of tokens to skip in the data sample + # prefix, for the respective cutoff length. Used to speed up the process + ctx_len_warmup_steps: [0, 0, 0, 0, 0, 0, 0] + + # Learning rate of the training process + # --- + # Initia learning rate of the process + lr_init: 6e-4 + # Final learning rate after the learning rate period + # learning rate will stay at final value from then onwards + # + # NOTE: lr_final / lr_period does not work with warmup_steps + # and will be ignored (or replaced) with the warmup_steps logic instead + lr_final: 4e-4 + # Number of epoch to reduce the learning rate from lr_init to lr_final + # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) + # 0 means lr_final will apply immediately + # -1 means we take the current max_step / max_epoch as the period + lr_period: 1 + # lr_period type if its set, defaults to epoch + lr_period_type: epoch + + # Adam optimizer settings + # You probably want to leave this alone, unless you know what you are doing + beta1: 0.9 + beta2: 0.99 + adam_eps: 1.0e-08 + weight_decay: 0.01 + + # torch.set_float32_matmul_precision, used to optimize operations with tensor cores + # this should be set as null, for non cuda core GPUs + torch_set_float32_matmul_precision: 'high' + # torch_set_float32_matmul_precision: null + + # Segmented based learning, used to work around training of large context length + # beyond what can be supported by the current GPU vram architecture + # + # This is not 1:1 equivalent to the same training process with required vram + # as the training process is split into multiple segments, part by part. + # with limited learnings from the previous segment. + bptt_learning: true + + # Segmented range to performing backprop learning on + # 1 means to apply only for the last segment + # -1 means to apply for all segments + bptt_learning_range: 2 + + # various other settings you probably should leave alone + grad_cp: true + warmup_steps: -1 + layerwise_lr: true + dim_att: null + dim_ffn: null +data: + # dataset_path for the prebuilt dataset, using HF `load_from_disk()` + # + # Use this if you have built your own dataset and saved it with `save_to_disk()` + # with source left as null. Other wise configure this to a directory which the + # dataset will be built and tokenized by the huggingface dataset process. + data_path: ../datapath/enwiki_10k_1024/ + + # Other wise provide the source path, which is used as huggingface dataset path + # this will be used to populate the dataset_path + # + # Use either the following + # - hugging face dataset + # - Directory path to a directory containing dataset files + # - Path to a single dataset file + # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) + # - null + # + # If source is disabled, all other params, except data_path, is ignored + source: "teven/enwiki_10k" + # source: text + # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt + + # Use data_dir, if you are using source=text/json/etc + # this should be relative to the data_path + source_data_dir: null + + # After loading the dataset, split out test data used for validation, + # This process is skipped if the dataset includes a test split + # This process is skipped if set to zero + test_split: 0.01 + test_split_shuffle: false + + # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer + # If using a custom tokenizer, provide the tokenizer file path + # --- + tokenizer: neox + + # Minimum / Maximum token size of the dataset to use + # useful for filtering out small noisy data samples from large datasets + # (eg. removal of small articles of less then 512 tokens from wikipedia) + # + # This is ignored, if set to -1 + min_token_size: 64 + max_token_size: -1 + + # Rechunking of text dataset, this is done only when source is set as 'text' + # and will merge the various sentencees, into larger chunks up to the target size + # + # Defaults to 4096 + # + # This is ignored, if source is not set as text + # This is ignored, if set to zero + # --- + text_rechunk_size: 1024 + + # Apply text rechunk to the dataset, even if its not a 'text' source + # This is done only after dataset filtering, and if source is not 'text' + # --- + text_rechunk_force: true + + # Custom text column to use, useful for dataset with alternative training columns labels + # This is checked before multi column merging, default is null (disabled) + # eg: 'code' + # --- + # custom_text_key: 'code' + + # Multi Column merging process, default setting is used to support and merge + # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] + # + # A minimum of 2 columns is required, with non empty data, for the merge to occur + # If no match is found, this will fallback to the default prompt/completion or text column, + # or throw an error if the default fallback is not found + # --- + # multi_column_keys: ['instruction', 'input', 'output'] + # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] + # multi_column_masking: [false, true, false] + # multi_column_seperator: '\n\n' + + # If processing prompt/completion jsonl pairs, the prompt is masked by default + # use this flag to disable this default behaviour + # --- + # disable_prompt_mask: false + +# Path to the current checkpoint to continue training from +# Enable this to the last checkpoint after the first run +# (if it crash and you want to resume) +# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-dryrun/epoch=0-step=20.ckpt +ckpt_path: null From 69be751e18ac9736fb662ba157ccb683f78d877f Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 08:29:15 +0000 Subject: [PATCH 19/57] dryrun config tweak --- notebook/trainer-validation/config-dryrun.yaml | 2 +- notebook/trainer-validation/infctx-validation-dryrun.yaml | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/notebook/trainer-validation/config-dryrun.yaml b/notebook/trainer-validation/config-dryrun.yaml index 4d4295c3..0e1abedb 100644 --- a/notebook/trainer-validation/config-dryrun.yaml +++ b/notebook/trainer-validation/config-dryrun.yaml @@ -240,7 +240,7 @@ model: # Segmented range to performing backprop learning on # 1 means to apply only for the last segment # -1 means to apply for all segments - bptt_learning_range: 2 + bptt_learning_range: -1 # various other settings you probably should leave alone grad_cp: true diff --git a/notebook/trainer-validation/infctx-validation-dryrun.yaml b/notebook/trainer-validation/infctx-validation-dryrun.yaml index 69544cc4..ab4e3145 100644 --- a/notebook/trainer-validation/infctx-validation-dryrun.yaml +++ b/notebook/trainer-validation/infctx-validation-dryrun.yaml @@ -3,7 +3,7 @@ seed_everything: 3941088705 trainer: # Configure the number of GPU, avaliable on your machine accelerator: gpu - devices: 1 + devices: auto num_nodes: 1 # @@ -24,7 +24,7 @@ trainer: # For more details see: # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 # - strategy: deepspeed_stage_2_offload + strategy: deepspeed_stage_3_offload # Floating point precision for the model, because RWKV is built FOR bf16 # you should pretty much never change this setting @@ -240,7 +240,7 @@ model: # Segmented range to performing backprop learning on # 1 means to apply only for the last segment # -1 means to apply for all segments - bptt_learning_range: 2 + bptt_learning_range: -1 # various other settings you probably should leave alone grad_cp: true From 31caa05d0a9c5c1ca7026483275ef1511f07afa9 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 09:15:31 +0000 Subject: [PATCH 20/57] Added aggressive cuda cache clear option --- RWKV-v4neo/config-example.yaml | 19 +++++++++++++++---- RWKV-v4neo/src/model.py | 11 ++++++++++- 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/RWKV-v4neo/config-example.yaml b/RWKV-v4neo/config-example.yaml index 8904ecef..98244d0f 100644 --- a/RWKV-v4neo/config-example.yaml +++ b/RWKV-v4neo/config-example.yaml @@ -128,13 +128,17 @@ trainer: # Number of datasamples to train for each step, a data sample is considered # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" # - # This decides the number of datasample, to learn together from, before backproping - # any weight changes at the end of the batch. + # This decides the number of datasample * the number of GPU devices, to learn together from, + # before backproping any weight changes at the end of the batch. # - # Recommended to be a big enough number (like 128/256) where it prevents the training - # loss from flucuating in the process. But not too big of a number where the increased + # `1 trainer/global_step = accumulate_grad_batches * number of GPU devices * number of nodes` + # + # Recommended to be a big enough number (like 128/256) for finetuning where it prevents the + # training loss from flucuating in the process. But not too big of a number where the increased # GPU vRAM usage will cause the training to crash. # + # For foundation model training, a low accumulate_grad_batches like 8/12/16 is recommended. + # # You are also recommended to configure this to a large enough number to fully utilize # your GPU processing time %, and avoid idle time for the GPU between batches accumulate_grad_batches: 256 @@ -237,6 +241,13 @@ model: # This is also known as tbptt (Truncated Back Propagation through time) bptt_truncated_learning: false + # Aggressively clear the cuda cache between each data samples. + # This causes a performance penalty, but reduces the vram pressure + # + # This is useful for mitigating the following memory pressure warning + # `1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance...` + aggresive_cuda_cache_clear: false + # various other settings you probably should leave alone grad_cp: true warmup_steps: -1 diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index fd21182a..e5afad4a 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -268,7 +268,8 @@ def __init__(self, dim_att: Optional[int] = None, dim_ffn: Optional[int] = None, load_model: Optional[str] = None, - torch_set_float32_matmul_precision:str = 'high' + torch_set_float32_matmul_precision:str = 'high', + aggresive_cuda_cache_clear: bool = False, ): super().__init__() self.ctx_len = ctx_len @@ -290,6 +291,7 @@ def __init__(self, self.bptt_learning = bptt_learning self.bptt_learning_range = bptt_learning_range self.bptt_truncated_learning = bptt_truncated_learning + self.aggresive_cuda_cache_clear = aggresive_cuda_cache_clear dim_att = dim_att or n_embd dim_ffn = dim_ffn or n_embd * 4 @@ -578,6 +580,9 @@ def manual_backward(self, loss: torch.Tensor, *args, **kwargs): # self._verify_is_manual_optimization("manual_backward") self.trainer.strategy.backward(loss, None, *args, **kwargs) + # + # Main compute_loss function, this is called by the trainer loop + # def compute_loss(self, batch, batch_idx, is_training_run: bool): seq = batch['input_ids'] assert isinstance(seq, torch.Tensor) and seq.ndim == 2 @@ -824,6 +829,10 @@ def training_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, True) self.log('train/loss', total_loss, prog_bar=True) + if self.aggresive_cuda_cache_clear: + gc.collect() + torch.cuda.empty_cache() + return total_loss def validation_step(self, batch, batch_idx): From ee3157805331c61a77f40231dfd4ada9c3397aae Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 14:29:40 +0000 Subject: [PATCH 21/57] rename to `substep_cuda_cache_clear` --- RWKV-v4neo/config-example.yaml | 2 +- RWKV-v4neo/src/model.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/RWKV-v4neo/config-example.yaml b/RWKV-v4neo/config-example.yaml index 98244d0f..eb5cf08d 100644 --- a/RWKV-v4neo/config-example.yaml +++ b/RWKV-v4neo/config-example.yaml @@ -246,7 +246,7 @@ model: # # This is useful for mitigating the following memory pressure warning # `1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance...` - aggresive_cuda_cache_clear: false + substep_cuda_cache_clear: false # various other settings you probably should leave alone grad_cp: true diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index e5afad4a..2c93eae7 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -269,7 +269,7 @@ def __init__(self, dim_ffn: Optional[int] = None, load_model: Optional[str] = None, torch_set_float32_matmul_precision:str = 'high', - aggresive_cuda_cache_clear: bool = False, + substep_cuda_cache_clear: bool = False, ): super().__init__() self.ctx_len = ctx_len @@ -291,7 +291,7 @@ def __init__(self, self.bptt_learning = bptt_learning self.bptt_learning_range = bptt_learning_range self.bptt_truncated_learning = bptt_truncated_learning - self.aggresive_cuda_cache_clear = aggresive_cuda_cache_clear + self.substep_cuda_cache_clear = substep_cuda_cache_clear dim_att = dim_att or n_embd dim_ffn = dim_ffn or n_embd * 4 @@ -829,7 +829,7 @@ def training_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, True) self.log('train/loss', total_loss, prog_bar=True) - if self.aggresive_cuda_cache_clear: + if self.substep_cuda_cache_clear: gc.collect() torch.cuda.empty_cache() From 6886abc1113d89f6ca61a4ff251fe2dff98ea962 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 17:02:42 +0000 Subject: [PATCH 22/57] tweak baseline setup --- .../trainer-validation/baseline-setup.ipynb | 57 +++++++------------ .../trainer-validation/config-baseline.yaml | 2 +- 2 files changed, 20 insertions(+), 39 deletions(-) diff --git a/notebook/trainer-validation/baseline-setup.ipynb b/notebook/trainer-validation/baseline-setup.ipynb index 123dd712..17648270 100644 --- a/notebook/trainer-validation/baseline-setup.ipynb +++ b/notebook/trainer-validation/baseline-setup.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# InfCtx trainer validation\n", + "# InfCtx trainer baseline setup\n", "The trainer validation is mostly done using the same settings as raven 1B5 model.\n", "- Layer count: 24\n", "- Embed size: 2048\n", @@ -105,50 +105,39 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Setting ds_accelerator to cuda (auto detect)\n", + "[2023-07-07 10:22:23,757] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", "Global seed set to 3941088705\n", "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", "Detected CUDA files, patching ldflags\n", "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_128_bf16/build.ninja...\n", "Building extension module wkv_128_bf16...\n", "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "[1/3] /usr/local/cuda/bin/nvcc -DTORCH_EXTENSION_NAME=wkv_128_bf16 -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\\\"_gcc\\\" -DPYBIND11_STDLIB=\\\"_libstdcpp\\\" -DPYBIND11_BUILD_ABI=\\\"_cxxabi1011\\\" -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/TH -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr -gencode=arch=compute_86,code=compute_86 -gencode=arch=compute_86,code=sm_86 --compiler-options '-fPIC' -t 4 -std=c++17 -res-usage --maxrregcount 60 --use_fast_math -O3 -Xptxas -O3 --extra-device-vectorization -DTmax=128 -c /home/ubuntu/RWKV-LM-LoRA-merge/RWKV-v4neo/cuda/wkv_cuda_bf16.cu -o wkv_cuda_bf16.cuda.o \n", - "ptxas info : 1 bytes gmem\n", - "ptxas info : Compiling entry function '_Z15kernel_backwardiiiPKfPKN3c108BFloat16ES4_S4_S0_S4_S0_PS2_S5_S5_S5_Pf' for 'sm_86'\n", - "ptxas info : Function properties for _Z15kernel_backwardiiiPKfPKN3c108BFloat16ES4_S4_S0_S4_S0_PS2_S5_S5_S5_Pf\n", - " 1536 bytes stack frame, 0 bytes spill stores, 0 bytes spill loads\n", - "ptxas info : Used 56 registers, 464 bytes cmem[0], 8 bytes cmem[2]\n", - "ptxas info : Compiling entry function '_Z14kernel_forwardiiiPKfPKN3c108BFloat16ES4_S4_S0_PS2_Pf' for 'sm_86'\n", - "ptxas info : Function properties for _Z14kernel_forwardiiiPKfPKN3c108BFloat16ES4_S4_S0_PS2_Pf\n", - " 0 bytes stack frame, 0 bytes spill stores, 0 bytes spill loads\n", - "ptxas info : Used 40 registers, 424 bytes cmem[0]\n", - "[2/3] c++ -MMD -MF wkv_op_bf16.o.d -DTORCH_EXTENSION_NAME=wkv_128_bf16 -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\\\"_gcc\\\" -DPYBIND11_STDLIB=\\\"_libstdcpp\\\" -DPYBIND11_BUILD_ABI=\\\"_cxxabi1011\\\" -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/TH -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda/include -isystem /home/ubuntu/anaconda3/envs/rwkv-exp/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -fPIC -std=c++17 -std=c++17 -O3 -DTmax=128 -c /home/ubuntu/RWKV-LM-LoRA-merge/RWKV-v4neo/cuda/wkv_op_bf16.cpp -o wkv_op_bf16.o \n", - "[3/3] c++ wkv_op_bf16.o wkv_cuda_bf16.cuda.o -shared -L/home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/torch/lib -lc10 -lc10_cuda -ltorch_cpu -ltorch_cuda -ltorch -ltorch_python -L/usr/local/cuda/lib64 -lcudart -o wkv_128_bf16.so\n", + "ninja: no work to do.\n", "Loading extension module wkv_128_bf16...\n", - "/home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", " rank_zero_warn(\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", - "/home/ubuntu/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", " warning_cache.warn(\n", - "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 970.45it/s]\n", - "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec/cache-08de1ca402bb082a_*_of_00032.arrow\n", - "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec/cache-a1f76c32471ce85a_*_of_00032.arrow\n", - "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/2a3b91fbd88a2c90d1dbbb32b460cf621d31bd5b05b934492fdef7d8d6f236ec/cache-2fdd1d8e3fc93ac5_*_of_00032.arrow\n", + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 928.56it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-85ed41912c749812_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-d919d919e3a12608_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f2a6e7ee57d796c9_*_of_00032.arrow\n", "[rank: 0] Global seed set to 3941088705 \n", "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "[2023-07-07 08:01:07,186] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", - "[2023-07-07 08:01:07,187] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "[2023-07-07 10:22:36,382] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-07 10:22:36,383] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", "Enabling DeepSpeed BF16.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", @@ -158,19 +147,8 @@ "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", "ninja: no work to do.\n", "Loading extension module cpu_adam...\n", - "Time to load cpu_adam op: 2.3342714309692383 seconds\n", - "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", - "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/utils/build.ninja...\n", - "Building extension module utils...\n", - "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "ninja: no work to do.\n", - "Loading extension module utils...\n", - "Time to load utils op: 0.060671091079711914 seconds\n", + "Time to load cpu_adam op: 2.343660354614258 seconds\n", "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", - "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", - "No modifications detected for re-loaded extension module utils, skipping build step...\n", - "Loading extension module utils...\n", - "Time to load utils op: 0.00025725364685058594 seconds\n", "\n", " | Name | Type | Params\n", "--------------------------------------\n", @@ -183,7 +161,10 @@ "0 Non-trainable params\n", "1.5 B Total params\n", "6,060.425 Total estimated model params size (MB)\n", - "Epoch 0: 0%| | 1/5308 [00:09<13:51:55, 9.41s/it, v_num=0, train/loss=11.00]" + "Epoch 0: 0%| | 1/5308 [00:14<20:44:47, 14.07s/it, v_num=7, train/loss=11.00]/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/deepspeed/runtime/zero/stage_1_and_2.py:1828: UserWarning: The torch.cuda.*DtypeTensor constructors are no longer recommended. It's best to use methods such as torch.tensor(data, dtype=*, device='cuda') to create tensors. (Triggered internally at /opt/conda/conda-bld/pytorch_1688627653114/work/torch/csrc/tensor/python_tensor.cpp:83.)\n", + " overflow_gpu = get_accelerator().ByteTensor([overflow])\n", + "Epoch 0: 0%| | 4/5308 [01:01<22:34:24, 15.32s/it, v_num=7, train/loss=9.620]`Trainer.fit` stopped: `max_steps=2` reached.\n", + "Epoch 0: 0%| | 4/5308 [01:01<22:34:28, 15.32s/it, v_num=7, train/loss=9.620]\n" ] } ], @@ -197,7 +178,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Baseline full context (1024) training\n", + "# (Optional) Baseline full context (1024) training\n", "\n", "Perform a full 1 epoch training run of training context size = 1024. Ensuring all data samples fit within the allocated training size. And is used as the baseline loss comparision for several experiments" ] diff --git a/notebook/trainer-validation/config-baseline.yaml b/notebook/trainer-validation/config-baseline.yaml index 453d2b0c..251939f4 100644 --- a/notebook/trainer-validation/config-baseline.yaml +++ b/notebook/trainer-validation/config-baseline.yaml @@ -136,7 +136,7 @@ trainer: # # You are also recommended to configure this to a large enough number to fully utilize # your GPU processing time %, and avoid idle time for the GPU between batches - accumulate_grad_batches: 12 + accumulate_grad_batches: 10 # Various other settings, you probably want to leave alone fast_dev_run: false From c1cd8d30429fe7f476492a17f78f07001ee0b4b5 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 17:11:25 +0000 Subject: [PATCH 23/57] tweak basline title --- notebook/trainer-validation/config-baseline.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebook/trainer-validation/config-baseline.yaml b/notebook/trainer-validation/config-baseline.yaml index 251939f4..ab894943 100644 --- a/notebook/trainer-validation/config-baseline.yaml +++ b/notebook/trainer-validation/config-baseline.yaml @@ -35,7 +35,7 @@ trainer: logger: class_path: lightning.pytorch.loggers.WandbLogger init_args: - name: 'infctx-validation-baseline (train-ctx=1024, data-ctx=1024, bs=12)' + name: 'infctx-validation-baseline (train-ctx=1024, data-ctx=1024, bs=10)' project: 'RWKV-infctx-validation' tags: ['RWKV', 'infctx'] id: null From ad934674c4d07bbacea3702e46da8b60ac5042e8 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 17:12:37 +0000 Subject: [PATCH 24/57] substep_logging mode --- RWKV-v4neo/src/model.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 2c93eae7..adc93f12 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -270,8 +270,10 @@ def __init__(self, load_model: Optional[str] = None, torch_set_float32_matmul_precision:str = 'high', substep_cuda_cache_clear: bool = False, + substep_logging: bool = False ): super().__init__() + self.ctx_len = ctx_len self.ctx_len_cutoffs = ctx_len_cutoffs self.ctx_len_warmup_steps = ctx_len_warmup_steps @@ -292,6 +294,7 @@ def __init__(self, self.bptt_learning_range = bptt_learning_range self.bptt_truncated_learning = bptt_truncated_learning self.substep_cuda_cache_clear = substep_cuda_cache_clear + self.substep_logging = substep_logging dim_att = dim_att or n_embd dim_ffn = dim_ffn or n_embd * 4 @@ -828,6 +831,9 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, def training_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, True) self.log('train/loss', total_loss, prog_bar=True) + # If set - forces the train/loss log line to always be on a new line + if self.substep_logging: + print("") if self.substep_cuda_cache_clear: gc.collect() From 856ec70a2f0806c8ee6905509ded5bf59c64a741 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 17:57:00 +0000 Subject: [PATCH 25/57] Adding torch compile / JIT flags --- RWKV-v4neo/src/model.py | 54 +++++++++++++++++++++++++++++------------ 1 file changed, 39 insertions(+), 15 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index adc93f12..9ced02d4 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -2,7 +2,7 @@ # The RWKV Language Model - https://github.com/BlinkDL/RWKV-LM ######################################################################################################## -import gc, math +import gc, math, os from random import randint from typing import List, Optional @@ -22,14 +22,42 @@ import deepspeed.runtime.lr_schedules import wandb -RWKV_JIT_ON = False -if RWKV_JIT_ON: - MyModule = torch.jit.ScriptModule - MyFunction = torch.jit.script_method +from torch.utils.cpp_extension import load + +######################################################################################################## +# JIT / torch compile special handling +######################################################################################################## + +# Currently the features we need for torch compile, is avaliable only in +# 2.1 nightly build (and is expected to be in 2.1 official release) +# +# We only enable torch compile, if we either the user has explicitly +# set it, or we detect that we are running on a 2.1+ build automatically +from packaging import version +def is_torch_version_above(required_version): + torch_version = version.parse(torch.__version__.split('+')[0]) + return torch_version >= version.parse(required_version) +IS_TORCH_2_1 = is_torch_version_above("2.0.9999") + +# Get the JIT / torch compile option flags from the environment +RWKV_JIT_ON = os.getenv("RWKV_JIT_ON", "1").lower() in ("1", "true", "yes") +RWKV_TORCH_COMPILE = os.getenv("RWKV_TORCH_COMPILE", "{IS_TORCH_2_1}").lower() in ("1", "true", "yes") + +# We enable JITModule/Function or torch compile function +# based on the current runtime settings +if RWKV_TORCH_COMPILE: + JITModule = nn.Module + JITFunction = lambda x: x +elif RWKV_JIT_ON: + JITModule = torch.jit.ScriptModule + JITFunction = torch.jit.script_method else: - MyModule = nn.Module - MyFunction = lambda x: x + JITModule = nn.Module + JITFunction = lambda x: x +######################################################################################################## +# RWKV: State Blocks +######################################################################################################## class TimeMixState: @@ -84,15 +112,11 @@ def __setitem__(self, layer: int, state: BlockState): self.wkv_states[layer] = state.time_mix_state.wkv_state self.shift_states[layer, 1] = state.channel_mix_state.shift_state - -from torch.utils.cpp_extension import load - ######################################################################################################## # RWKV: RWKV Time-mix + RWKV Channel-mix ######################################################################################################## - -class RWKV_TimeMix(MyModule): +class RWKV_TimeMix(JITModule): def __init__(self, layer_id, n_layer, n_embd, dim_att): super().__init__() @@ -131,7 +155,7 @@ def __init__(self, layer_id, n_layer, n_embd, dim_att): self.receptance = nn.Linear(n_embd, dim_att, bias=False) self.output = nn.Linear(dim_att, n_embd, bias=False) - @MyFunction + @JITFunction def forward(self, x, last_state: TimeMixState): # Mix x with the previous timestep to produce xk, xv, xr xx = torch.concat((last_state.shift_state.unsqueeze(1), x[:, :-1]), @@ -154,7 +178,7 @@ def forward(self, x, last_state: TimeMixState): ######################################################################################################## -class RWKV_ChannelMix(MyModule): +class RWKV_ChannelMix(JITModule): def __init__(self, layer_id, n_layer, n_embd, dim_ffn): super().__init__() @@ -171,7 +195,7 @@ def __init__(self, layer_id, n_layer, n_embd, dim_ffn): self.receptance = nn.Linear(n_embd, n_embd, bias=False) self.value = nn.Linear(dim_ffn, n_embd, bias=False) - @MyFunction + @JITFunction def forward(self, x, last_state: ChannelMixState): xx = torch.concat((last_state.shift_state.unsqueeze(1), x[:, :-1]), dim=1) From 5a5bc5a9e2e85747e76fc9fb16172582ac26653a Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 18:08:33 +0000 Subject: [PATCH 26/57] updated baseline pytorch --- .../trainer-validation/baseline-setup.ipynb | 36 +++++++++++++------ 1 file changed, 25 insertions(+), 11 deletions(-) diff --git a/notebook/trainer-validation/baseline-setup.ipynb b/notebook/trainer-validation/baseline-setup.ipynb index 17648270..54aa4b0e 100644 --- a/notebook/trainer-validation/baseline-setup.ipynb +++ b/notebook/trainer-validation/baseline-setup.ipynb @@ -99,27 +99,41 @@ "source": [ "# Trainer Code validation via dryrun\n", "\n", - "The following dryrun, helps check that the existing trainer code changes are valid across 2 * 2 data samples.\n", + "The following dryrun, help do a basic check that the existing trainer code changes are valid across 2 * 2 data samples.\n", + "\n", + "If this check fail, its most probably a code / envrionment setup issue (no further checks needed)\n", + "\n", "It does not log the run the W&B" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[2023-07-07 10:22:23,757] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[2023-07-07 18:02:16,462] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", "Global seed set to 3941088705\n", "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", "Detected CUDA files, patching ldflags\n", "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_128_bf16/build.ninja...\n", "Building extension module wkv_128_bf16...\n", "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "ninja: no work to do.\n", + "[1/3] /usr/local/cuda/bin/nvcc -DTORCH_EXTENSION_NAME=wkv_128_bf16 -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\\\"_gcc\\\" -DPYBIND11_STDLIB=\\\"_libstdcpp\\\" -DPYBIND11_BUILD_ABI=\\\"_cxxabi1011\\\" -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/include -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/include/TH -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda/include -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_BFLOAT16_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr -gencode=arch=compute_86,code=compute_86 -gencode=arch=compute_86,code=sm_86 --compiler-options '-fPIC' -t 4 -std=c++17 -res-usage --maxrregcount 60 --use_fast_math -O3 -Xptxas -O3 --extra-device-vectorization -DTmax=128 -c /home/ubuntu/RWKV-LM-LoRA-merge/RWKV-v4neo/cuda/wkv_cuda_bf16.cu -o wkv_cuda_bf16.cuda.o \n", + "ptxas info : 1 bytes gmem\n", + "ptxas info : Compiling entry function '_Z15kernel_backwardiiiPKfPKN3c108BFloat16ES4_S4_S0_S4_S0_PS2_S5_S5_S5_Pf' for 'sm_86'\n", + "ptxas info : Function properties for _Z15kernel_backwardiiiPKfPKN3c108BFloat16ES4_S4_S0_S4_S0_PS2_S5_S5_S5_Pf\n", + " 1536 bytes stack frame, 0 bytes spill stores, 0 bytes spill loads\n", + "ptxas info : Used 56 registers, 464 bytes cmem[0], 8 bytes cmem[2]\n", + "ptxas info : Compiling entry function '_Z14kernel_forwardiiiPKfPKN3c108BFloat16ES4_S4_S0_PS2_Pf' for 'sm_86'\n", + "ptxas info : Function properties for _Z14kernel_forwardiiiPKfPKN3c108BFloat16ES4_S4_S0_PS2_Pf\n", + " 0 bytes stack frame, 0 bytes spill stores, 0 bytes spill loads\n", + "ptxas info : Used 40 registers, 424 bytes cmem[0]\n", + "[2/3] c++ -MMD -MF wkv_op_bf16.o.d -DTORCH_EXTENSION_NAME=wkv_128_bf16 -DTORCH_API_INCLUDE_EXTENSION_H -DPYBIND11_COMPILER_TYPE=\\\"_gcc\\\" -DPYBIND11_STDLIB=\\\"_libstdcpp\\\" -DPYBIND11_BUILD_ABI=\\\"_cxxabi1011\\\" -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/include -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/include/torch/csrc/api/include -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/include/TH -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/include/THC -isystem /usr/local/cuda/include -isystem /home/ubuntu/anaconda3/envs/rwkv-infctx/include/python3.11 -D_GLIBCXX_USE_CXX11_ABI=0 -fPIC -std=c++17 -std=c++17 -O3 -DTmax=128 -c /home/ubuntu/RWKV-LM-LoRA-merge/RWKV-v4neo/cuda/wkv_op_bf16.cpp -o wkv_op_bf16.o \n", + "[3/3] c++ wkv_op_bf16.o wkv_cuda_bf16.cuda.o -shared -L/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/lib -lc10 -lc10_cuda -ltorch_cpu -ltorch_cuda -ltorch -ltorch_python -L/usr/local/cuda/lib64 -lcudart -o wkv_128_bf16.so\n", "Loading extension module wkv_128_bf16...\n", "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", " rank_zero_warn(\n", @@ -130,14 +144,14 @@ "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", " warning_cache.warn(\n", "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 928.56it/s]\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 931.45it/s]\n", "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-85ed41912c749812_*_of_00032.arrow\n", "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-d919d919e3a12608_*_of_00032.arrow\n", "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f2a6e7ee57d796c9_*_of_00032.arrow\n", "[rank: 0] Global seed set to 3941088705 \n", "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "[2023-07-07 10:22:36,382] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", - "[2023-07-07 10:22:36,383] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "[2023-07-07 18:02:50,023] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-07 18:02:50,023] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", "Enabling DeepSpeed BF16.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", @@ -147,7 +161,7 @@ "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", "ninja: no work to do.\n", "Loading extension module cpu_adam...\n", - "Time to load cpu_adam op: 2.343660354614258 seconds\n", + "Time to load cpu_adam op: 2.3348190784454346 seconds\n", "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", "\n", " | Name | Type | Params\n", @@ -161,10 +175,10 @@ "0 Non-trainable params\n", "1.5 B Total params\n", "6,060.425 Total estimated model params size (MB)\n", - "Epoch 0: 0%| | 1/5308 [00:14<20:44:47, 14.07s/it, v_num=7, train/loss=11.00]/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/deepspeed/runtime/zero/stage_1_and_2.py:1828: UserWarning: The torch.cuda.*DtypeTensor constructors are no longer recommended. It's best to use methods such as torch.tensor(data, dtype=*, device='cuda') to create tensors. (Triggered internally at /opt/conda/conda-bld/pytorch_1688627653114/work/torch/csrc/tensor/python_tensor.cpp:83.)\n", + "Epoch 0: 0%| | 1/5308 [00:16<24:51:09, 16.86s/it, v_num=8, train/loss=11.00]/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/deepspeed/runtime/zero/stage_1_and_2.py:1828: UserWarning: The torch.cuda.*DtypeTensor constructors are no longer recommended. It's best to use methods such as torch.tensor(data, dtype=*, device='cuda') to create tensors. (Triggered internally at /opt/conda/conda-bld/pytorch_1688627653114/work/torch/csrc/tensor/python_tensor.cpp:83.)\n", " overflow_gpu = get_accelerator().ByteTensor([overflow])\n", - "Epoch 0: 0%| | 4/5308 [01:01<22:34:24, 15.32s/it, v_num=7, train/loss=9.620]`Trainer.fit` stopped: `max_steps=2` reached.\n", - "Epoch 0: 0%| | 4/5308 [01:01<22:34:28, 15.32s/it, v_num=7, train/loss=9.620]\n" + "Epoch 0: 0%| | 4/5308 [01:04<23:34:38, 16.00s/it, v_num=8, train/loss=9.620]`Trainer.fit` stopped: `max_steps=2` reached.\n", + "Epoch 0: 0%| | 4/5308 [01:04<23:34:41, 16.00s/it, v_num=8, train/loss=9.620]\n" ] } ], From e350c60f37dfda0255ddd57684b17843e5955b6e Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Fri, 7 Jul 2023 18:38:23 +0000 Subject: [PATCH 27/57] WIP torch compile notebooks --- RWKV-v4neo/src/model.py | 8 +- .../torch-compile-performance.ipynb | 260 ++++++++++++++++++ 2 files changed, 267 insertions(+), 1 deletion(-) create mode 100644 notebook/trainer-validation/torch-compile-performance.ipynb diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 9ced02d4..fe4256ed 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -41,20 +41,26 @@ def is_torch_version_above(required_version): # Get the JIT / torch compile option flags from the environment RWKV_JIT_ON = os.getenv("RWKV_JIT_ON", "1").lower() in ("1", "true", "yes") -RWKV_TORCH_COMPILE = os.getenv("RWKV_TORCH_COMPILE", "{IS_TORCH_2_1}").lower() in ("1", "true", "yes") +RWKV_TORCH_COMPILE = os.getenv("RWKV_TORCH_COMPILE", f"{IS_TORCH_2_1}").lower() in ("1", "true", "yes") +RWKV_TORCH_RUN_MODE = None # We enable JITModule/Function or torch compile function # based on the current runtime settings if RWKV_TORCH_COMPILE: + RWKV_TORCH_RUN_MODE = "torch-compile" JITModule = nn.Module JITFunction = lambda x: x elif RWKV_JIT_ON: + RWKV_TORCH_RUN_MODE = "torch-jit" JITModule = torch.jit.ScriptModule JITFunction = torch.jit.script_method else: + RWKV_TORCH_RUN_MODE = "torch-native" JITModule = nn.Module JITFunction = lambda x: x +print(f"[RWKV.model] Running RWKV model with : {RWKV_TORCH_RUN_MODE}") + ######################################################################################################## # RWKV: State Blocks ######################################################################################################## diff --git a/notebook/trainer-validation/torch-compile-performance.ipynb b/notebook/trainer-validation/torch-compile-performance.ipynb new file mode 100644 index 00000000..f9e368e5 --- /dev/null +++ b/notebook/trainer-validation/torch-compile-performance.ipynb @@ -0,0 +1,260 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# InfCtx torch.compile performance uplift\n", + "The following trainer validation, is used to compare performance differences between the following optimizations\n", + "\n", + "- torch native\n", + "- torch + JIT\n", + "- torch + torch.compile\n", + "\n", + "It presumes that basic setup has been done as per\n", + "- `./baseline-setup.ipynb`" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install the nightly build within conda\n", + "(Skip if you already have 2.0.2, or already done the setup)\n", + "\n", + "For torch.compile, as of 8th July 2023, you will need the torch nightly build for several fixes we depend on. This is expected to be resolved when merged in for torch 2.0.2 (you will need to call this outside the notebook)\n", + "\n", + "```bash\n", + "conda activate rwkv-infctx\n", + "conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch-nightly -c nvidia\n", + "```\n", + "\n", + "To simplify the benchmarking, we are intentionally only performing\n", + "- a 100 trainer/global_step\n", + "- of 10 gradient accumulation * gpu\n", + "- no checkpoint save to disk\n", + "\n", + "This would (on a single GPU) perform the run over\n", + "- a 1000 data samples" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configure and apply your preferred settings\n", + "( note you will need to rerun this cell, if you restart your env )" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DEEPSPEED_STRAT: deepspeed_stage_2_offload\n", + "ENABLE_WANDB: False\n" + ] + } + ], + "source": [ + "DEEPSPEED_STRAT=\"deepspeed_stage_2_offload\"\n", + "ENABLE_WANDB=False\n", + "\n", + "print(\"DEEPSPEED_STRAT:\", DEEPSPEED_STRAT)\n", + "print(\"ENABLE_WANDB:\", ENABLE_WANDB)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run, and get baseline timing (no JIT / torch compile)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WANDB: False\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-07-07 18:25:17,089] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[RWKV.model] Running RWKV model with : torch-native\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Global seed set to 3941088705\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_128_bf16/build.ninja...\n", + "Building extension module wkv_128_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ninja: no work to do.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading extension module wkv_128_bf16...\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", + " warning_cache.warn(\n", + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|██████████| 1/1 [00:00<00:00, 906.48it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-85ed41912c749812_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-d919d919e3a12608_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f2a6e7ee57d796c9_*_of_00032.arrow\n", + "[rank: 0] Global seed set to 3941088705 \n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-07-07 18:25:29,821] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-07 18:25:29,822] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Enabling DeepSpeed BF16.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ninja: no work to do.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading extension module cpu_adam...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time to load cpu_adam op: 2.3277952671051025 seconds\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/deepspeed/runtime/zero/stage_1_and_2.py:1828: UserWarning: The torch.cuda.*DtypeTensor constructors are no longer recommended. It's best to use methods such as torch.tensor(data, dtype=*, device='cuda') to create tensors. (Triggered internally at /opt/conda/conda-bld/pytorch_1688627653114/work/torch/csrc/tensor/python_tensor.cpp:83.)\n", + " overflow_gpu = get_accelerator().ByteTensor([overflow])\n", + "`Trainer.fit` stopped: `max_steps=2` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: 0%| | 4/5308 [01:01<22:28:21, 15.25s/it, v_num=10, train/loss=9.620]\n" + ] + } + ], + "source": [ + "%%bash -s \"$DEEPSPEED_STRAT\" \"$ENABLE_WANDB\"\n", + "\n", + "export RWKV_TORCH_COMPILE=0 \n", + "export RWKV_JIT_ON=0\n", + "if [ \"$2\" = \"False\" ]; then\n", + " export WANDB_MODE=\"disabled\"\n", + "fi\n", + "\n", + "cd ../../RWKV-v4neo\n", + "\n", + "python3 new_train.py fit \\\n", + " -c ../notebook/trainer-validation/config-baseline.yaml \\\n", + " --trainer.strategy=\"$1\" \\\n", + " --trainer.logger.init_args.name=\"infctx-validation-baseline (OS environment vars: RWKV_JIT_ON=False, RWKV_TORCH_COMPILE=False)\" \\\n", + " --trainer.max_epochs=-1 --trainer.max_steps:1000" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "rwkv-infctx", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 87755ceb764fe6aa99dcb2eef1ed37a0c1254292 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 05:39:14 +0000 Subject: [PATCH 28/57] WIP notebook organizing --- .../trainer-validation/baseline-setup.ipynb | 8 +- .../baseline-1024.yaml} | 0 .../baseline-dryrun.yaml} | 0 .../config/torch-compile-perf.yaml | 342 ++++++ .../torch-compile-perf.ipynb | 1057 +++++++++++++++++ .../torch-compile-performance.ipynb | 260 ---- 6 files changed, 1404 insertions(+), 263 deletions(-) rename notebook/trainer-validation/{config-baseline.yaml => config/baseline-1024.yaml} (100%) rename notebook/trainer-validation/{config-dryrun.yaml => config/baseline-dryrun.yaml} (100%) create mode 100644 notebook/trainer-validation/config/torch-compile-perf.yaml create mode 100644 notebook/trainer-validation/torch-compile-perf.ipynb delete mode 100644 notebook/trainer-validation/torch-compile-performance.ipynb diff --git a/notebook/trainer-validation/baseline-setup.ipynb b/notebook/trainer-validation/baseline-setup.ipynb index 54aa4b0e..56a421db 100644 --- a/notebook/trainer-validation/baseline-setup.ipynb +++ b/notebook/trainer-validation/baseline-setup.ipynb @@ -15,6 +15,8 @@ "\n", "The following notebook, helps perform the basic download and setup for the \"init model\", and \"test dataset\". Which is used as a reference point for all other validation processes (unless stated otherwise)\n", "\n", + "Generally you only need to do this once\n", + "\n", "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps\n", ">\n", "> All training runs (except dryrun) is configured to log to weights and bias, comment out the logger in the config file if you want to avoid this" @@ -89,7 +91,7 @@ ], "source": [ "# Lets preload the requried dataset\n", - "!cd ../../RWKV-v4neo && python3 preload_dataset.py ../notebook/trainer-validation/baseline-run.yaml" + "!cd ../../RWKV-v4neo && python3 preload_dataset.py ../notebook/trainer-validation/config/baseline-dryrun.yaml" ] }, { @@ -184,7 +186,7 @@ ], "source": [ "# Validate source code and env is working, by doing a short 2 sample dryrun\n", - "!cd ../../RWKV-v4neo && python3 new_train.py fit -c ../notebook/trainer-validation/config-dryrun.yaml" + "!cd ../../RWKV-v4neo && python3 new_train.py fit -c ../notebook/trainer-validation/config/baseline-dryrun.yaml" ] }, { @@ -350,7 +352,7 @@ ], "source": [ "# Full training run\n", - "!cd ../../RWKV-v4neo && python3 new_train.py fit -c ../notebook/trainer-validation/config-baseline.yaml" + "!cd ../../RWKV-v4neo && python3 new_train.py fit -c ../notebook/trainer-validation/config/baseline-1024.yaml" ] } ], diff --git a/notebook/trainer-validation/config-baseline.yaml b/notebook/trainer-validation/config/baseline-1024.yaml similarity index 100% rename from notebook/trainer-validation/config-baseline.yaml rename to notebook/trainer-validation/config/baseline-1024.yaml diff --git a/notebook/trainer-validation/config-dryrun.yaml b/notebook/trainer-validation/config/baseline-dryrun.yaml similarity index 100% rename from notebook/trainer-validation/config-dryrun.yaml rename to notebook/trainer-validation/config/baseline-dryrun.yaml diff --git a/notebook/trainer-validation/config/torch-compile-perf.yaml b/notebook/trainer-validation/config/torch-compile-perf.yaml new file mode 100644 index 00000000..0ca3a7ef --- /dev/null +++ b/notebook/trainer-validation/config/torch-compile-perf.yaml @@ -0,0 +1,342 @@ +# lightning.pytorch==2.0.2 +seed_everything: 3941088705 +trainer: + # Configure the number of GPU, avaliable on your machine + accelerator: gpu + devices: auto + num_nodes: 1 + + # + # Configure the deepspeed strategy, we recommend you start with `deepspeed_stage_2_offload` + # and adjust from there according to your training needs. `deepspeed_stage_3_offload` is useful + # for training LoRA on large models on a single GPU. + # + # In general you would want to use the following: + # + # - deepspeed_stage_1 : Each of your GPU has too much vram, and you do not know what to do + # + # - deepspeed_stage_2 : Optimal distributed training strategy, across multiple gpu each with sufficient vram + # - deepspeed_stage_2_offload : Reduce vram usage by offloading the optimizer state and work to cpu + # + # - deepspeed_stage_3 : Split up the model across multiple gpu, useful for large models, at a performance cost + # - deepspeed_stage_3_offload : Additional offloading, for even greater performance cost + # + # For more details see: + # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 + # + strategy: deepspeed_stage_2_offload + + # Floating point precision for the model, because RWKV is built FOR bf16 + # you should pretty much never change this setting + precision: bf16 + + # Logger setting for wandb, if you want to enable wandb, uncomment the whole logger section + # --- + logger: + class_path: lightning.pytorch.loggers.WandbLogger + init_args: + name: 'infctx-torch-compile-perf' + project: 'RWKV-infctx-validation' + tags: ['RWKV', 'infctx'] + id: null + save_dir: . + version: null + offline: false + dir: null + anonymous: null + log_model: false + experiment: null + prefix: '' + checkpoint_name: null + job_type: null + config: null + entity: null + reinit: null + group: null + notes: null + magic: null + config_exclude_keys: null + config_include_keys: null + mode: null + allow_val_change: null + resume: null + force: null + tensorboard: null + sync_tensorboard: null + monitor_gym: null + save_code: null + settings: null + + # Checkpoint settings for the training process + callbacks: + - class_path: lightning.pytorch.callbacks.ModelCheckpoint + init_args: + # Configure this to the path you want to save your checkpoints to + # note that a subdir will be created with the name `epoch=x-step=y.ckpt` + # + # to convert a checkpoint to a model, you can use the + # `python3 export_checkpoint.py ` script, + # which will create a `rwkv_model.pth` in the checkpoint directory. + # + # Do not use the `zero_to_fp32.py` script as that will have export format issues + dirpath: ../checkpoint/trainer-validaiton/infctx-validation-torch-perf + filename: null + + # Save the top/last K checkpoints + save_top_k: 3 + # Choose by the most recent checkpoints (step based) + monitor: 'step' + mode: max + + # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' + # useful to simply checkpoint resume scripts, at a price of disk performance + save_last: false + + # DO NOT set this as true, as the model weight exported will have format issues + # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead + save_weights_only: false + + # How frequent you want to save a checkpoint for every step. + # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches + # + # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) + # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process + # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes + every_n_train_steps: 5000 + every_n_epochs: null + save_on_train_epoch_end: true + train_time_interval: null + + # Other settings, you can probably leave alone + verbose: false + auto_insert_metric_name: true + + ######################################## + ## Training run parameter settings + ######################################## + + # Generally what you want to configure is the maximum number of epochs + # Leave it as -1, and it will keep going forever till interrupted + # Or set it as a number, and it will stop after that number of epochs + max_epochs: -1 + min_epochs: null + max_steps: 100 + min_steps: null + max_time: null + + # Number of datasamples to train for each step, a data sample is considered + # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" + # + # This decides the number of datasample, to learn together from, before backproping + # any weight changes at the end of the batch. + # + # Recommended to be a big enough number (like 128/256) where it prevents the training + # loss from flucuating in the process. But not too big of a number where the increased + # GPU vRAM / offloaded RAM usage will cause the training to crash. + # + # You are also recommended to configure this to a large enough number to fully utilize + # your GPU processing time %, and avoid idle time for the GPU between batches + accumulate_grad_batches: 10 + + # Various other settings, you probably want to leave alone + fast_dev_run: false + limit_train_batches: null + limit_val_batches: null + limit_test_batches: null + limit_predict_batches: null + overfit_batches: 0.0 + val_check_interval: null + check_val_every_n_epoch: 1 + num_sanity_val_steps: 0 + log_every_n_steps: 1 + enable_checkpointing: true + enable_progress_bar: null + enable_model_summary: null + gradient_clip_val: 1.0 + gradient_clip_algorithm: null + deterministic: null + benchmark: null + inference_mode: true + use_distributed_sampler: true + profiler: null + detect_anomaly: false + barebones: false + plugins: null + sync_batchnorm: false + reload_dataloaders_every_n_epochs: 0 + default_root_dir: null + +######################################## +## Training model settings +######################################## +model: + # Model to start the finetune/training process from + load_model: ../model/Echo-A-1B5-Init.pth + + # The model size setting, this MUST match + # your current model settings, refer to the model card + # of the downloaded model for more details + n_embd: 2048 + n_layer: 24 + vocab_size: 50277 + + # Context length to use for the training process + # the larger the number (and batch size) the larger the vram usage + # + # Note that if the datasample context length is larger then the ctx_len + # its training process would be split into ctx_len sized chunks. + # + # This allows the training of extreamly large context length (eg. 100k), + # without eating up too much vram by keeping the training context length + # to a resonable number sutible to the current GPU setup + ctx_len: 4096 + + # Data samples would be cut down to the respective max ctx_len_cutoffs + # values if its larger then ctx_len. If the data sample is larger then + # the largest len_cutoff, the remaining data will be discarded + ctx_len_cutoffs: [4096, 8192, 16384, 32768, 65536] + # Experimental settings, number of tokens to skip in the data sample + # prefix, for the respective cutoff length. Used to speed up the process + ctx_len_warmup_steps: [0, 0, 0, 0, 0] + + # Learning rate of the training process + # --- + # Initia learning rate of the process + lr_init: 6e-4 + # Final learning rate after the learning rate period + # learning rate will stay at final value from then onwards + # + # NOTE: lr_final / lr_period does not work with warmup_steps + # and will be ignored (or replaced) with the warmup_steps logic instead + lr_final: 4e-4 + # Number of epoch to reduce the learning rate from lr_init to lr_final + # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) + # 0 means lr_final will apply immediately + # -1 means we take the current max_step / max_epoch as the period + lr_period: 1 + # lr_period type if its set, defaults to epoch + lr_period_type: epoch + + # Adam optimizer settings + # You probably want to leave this alone, unless you know what you are doing + beta1: 0.9 + beta2: 0.99 + adam_eps: 1.0e-08 + weight_decay: 0.01 + + # torch.set_float32_matmul_precision, used to optimize operations with tensor cores + # this should be set as null, for non cuda core GPUs + torch_set_float32_matmul_precision: 'high' + # torch_set_float32_matmul_precision: null + + # Segmented based learning, used to work around training of large context length + # beyond what can be supported by the current GPU vram architecture + # + # This is not 1:1 equivalent to the same training process with required vram + # as the training process is split into multiple segments, part by part. + # with limited learnings from the previous segment. + bptt_learning: false + + # Segmented range to performing backprop learning on + # 1 means to apply only for the last segment + # -1 means to apply for all segments + bptt_learning_range: -1 + + # Force each substep to be logged as a seperate line + substep_logging: true + + # various other settings you probably should leave alone + grad_cp: true + warmup_steps: -1 + layerwise_lr: true + dim_att: null + dim_ffn: null +data: + # dataset_path for the prebuilt dataset, using HF `load_from_disk()` + # + # Use this if you have built your own dataset and saved it with `save_to_disk()` + # with source left as null. Other wise configure this to a directory which the + # dataset will be built and tokenized by the huggingface dataset process. + data_path: ../datapath/enwiki_10k_4096/ + + # Other wise provide the source path, which is used as huggingface dataset path + # this will be used to populate the dataset_path + # + # Use either the following + # - hugging face dataset + # - Directory path to a directory containing dataset files + # - Path to a single dataset file + # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) + # - null + # + # If source is disabled, all other params, except data_path, is ignored + source: "teven/enwiki_10k" + # source: text + # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt + + # Use data_dir, if you are using source=text/json/etc + # this should be relative to the data_path + source_data_dir: null + + # After loading the dataset, split out test data used for validation, + # This process is skipped if the dataset includes a test split + # This process is skipped if set to zero + test_split: 0.01 + test_split_shuffle: false + + # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer + # If using a custom tokenizer, provide the tokenizer file path + # --- + tokenizer: neox + + # Minimum / Maximum token size of the dataset to use + # useful for filtering out small noisy data samples from large datasets + # (eg. removal of small articles of less then 512 tokens from wikipedia) + # + # This is ignored, if set to -1 + min_token_size: 64 + max_token_size: -1 + + # Rechunking of text dataset, this is done only when source is set as 'text' + # and will merge the various sentencees, into larger chunks up to the target size + # + # Defaults to 4096 + # + # This is ignored, if source is not set as text + # This is ignored, if set to zero + # --- + text_rechunk_size: 4096 + + # Apply text rechunk to the dataset, even if its not a 'text' source + # This is done only after dataset filtering, and if source is not 'text' + # --- + text_rechunk_force: true + + # Custom text column to use, useful for dataset with alternative training columns labels + # This is checked before multi column merging, default is null (disabled) + # eg: 'code' + # --- + # custom_text_key: 'code' + + # Multi Column merging process, default setting is used to support and merge + # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] + # + # A minimum of 2 columns is required, with non empty data, for the merge to occur + # If no match is found, this will fallback to the default prompt/completion or text column, + # or throw an error if the default fallback is not found + # --- + # multi_column_keys: ['instruction', 'input', 'output'] + # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] + # multi_column_masking: [false, true, false] + # multi_column_seperator: '\n\n' + + # If processing prompt/completion jsonl pairs, the prompt is masked by default + # use this flag to disable this default behaviour + # --- + # disable_prompt_mask: false + +# Path to the current checkpoint to continue training from +# Enable this to the last checkpoint after the first run +# (if it crash and you want to resume) +# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-baseline/epoch=0-step=20.ckpt +ckpt_path: null diff --git a/notebook/trainer-validation/torch-compile-perf.ipynb b/notebook/trainer-validation/torch-compile-perf.ipynb new file mode 100644 index 00000000..e23526de --- /dev/null +++ b/notebook/trainer-validation/torch-compile-perf.ipynb @@ -0,0 +1,1057 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# InfCtx torch.compile performance uplift\n", + "The following trainer validation, is used to compare performance differences between the following optimizations\n", + "\n", + "- torch native\n", + "- torch + JIT\n", + "- torch + torch.compile\n", + "\n", + "It presumes that basic setup has been done as per\n", + "- `./baseline-setup.ipynb`\n", + "\n", + "To simplify the benchmarking, we are intentionally only performing\n", + "- a 100 trainer/global_step\n", + "- of 10 gradient accumulation (per GPU)\n", + "- no checkpoint save to disk (reduce the influence of random diskio in timings)\n", + "\n", + "This would (on a single GPU) perform the run over\n", + "- a 1000 data samples" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install the nightly build within conda\n", + "(Skip if you already have 2.0.2, or already done the setup)\n", + "\n", + "For torch.compile, as of 8th July 2023, you will need the torch nightly build for several fixes we depend on. This is expected to be resolved when merged in for torch 2.0.2 (you will need to call this outside the notebook)\n", + "\n", + "```bash\n", + "conda activate rwkv-infctx\n", + "conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch-nightly -c nvidia\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configure and apply your preferred settings\n", + "\n", + "Adjust your desired deepspeed settings, and gpu device count.\n", + "Enable/Disable WANDB here as well (recommended disabled, to reduce perf impact)\n", + "\n", + "( note you will need to rerun this cell, if you restart your env )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DEEPSPEED_STRAT: deepspeed_stage_2_offload\n", + "GPU_DEVICES: auto\n", + "ENABLE_WANDB: False\n" + ] + } + ], + "source": [ + "DEEPSPEED_STRAT=\"deepspeed_stage_2_offload\"\n", + "GPU_DEVICES=\"auto\"\n", + "ENABLE_WANDB=False\n", + "\n", + "print(\"DEEPSPEED_STRAT:\", DEEPSPEED_STRAT)\n", + "print(\"ENABLE_WANDB:\", ENABLE_WANDB)\n", + "print(\"GPU_DEVICES:\", GPU_DEVICES)\n", + "\n", + "if ENABLE_WANDB:\n", + " WANDB_MODE=\"online\"\n", + "else:\n", + " WANDB_MODE=\"disabled\"\n", + "\n", + "# Ensure logs dir is initialized\n", + "!mkdir -p /logs/" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preload your data\n", + "The data has minor differences from baseline, and needs to be preloaded here" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 973.16it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-a9b10ddaafcd70a8_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-cfd32fc41583b797_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f22a54fa61543287_*_of_00032.arrow\n", + " \r" + ] + } + ], + "source": [ + "!cd ../../RWKV-v4neo && python3 preload_dataset.py ../notebook/trainer-validation/config/torch-compile-perf.yaml" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Perform baseline benchmark (no JIT / no toch compile)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-07-08 05:13:47,599] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[RWKV.model] Running RWKV model with : torch-native\n", + "Global seed set to 3941088705\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_4096_bf16/build.ninja...\n", + "Building extension module wkv_4096_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module wkv_4096_bf16...\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 965.10it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-a9b10ddaafcd70a8_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-cfd32fc41583b797_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f22a54fa61543287_*_of_00032.arrow\n", + "[rank: 0] Global seed set to 3941088705 \n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[2023-07-08 05:14:01,190] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-08 05:14:01,191] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "Enabling DeepSpeed BF16.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096)\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module cpu_adam...\n", + "Time to load cpu_adam op: 2.3342676162719727 seconds\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "Epoch 0: 0%| | 0/1315 [00:00 Date: Sat, 8 Jul 2023 07:54:10 +0000 Subject: [PATCH 29/57] WIP torch compile perf notebook --- .../torch-compile-perf.ipynb | 2605 ++++++++++++++++- 1 file changed, 2591 insertions(+), 14 deletions(-) diff --git a/notebook/trainer-validation/torch-compile-perf.ipynb b/notebook/trainer-validation/torch-compile-perf.ipynb index e23526de..bfa69d71 100644 --- a/notebook/trainer-validation/torch-compile-perf.ipynb +++ b/notebook/trainer-validation/torch-compile-perf.ipynb @@ -9,7 +9,7 @@ } }, "source": [ - "# InfCtx torch.compile performance uplift\n", + "# torch.compile performance uplift validation\n", "The following trainer validation, is used to compare performance differences between the following optimizations\n", "\n", "- torch native\n", @@ -20,12 +20,16 @@ "- `./baseline-setup.ipynb`\n", "\n", "To simplify the benchmarking, we are intentionally only performing\n", + "- training & data ctx len fixed at 4096\n", "- a 100 trainer/global_step\n", "- of 10 gradient accumulation (per GPU)\n", "- no checkpoint save to disk (reduce the influence of random diskio in timings)\n", "\n", "This would (on a single GPU) perform the run over\n", - "- a 1000 data samples" + "- a 1000 data samples\n", + "\n", + "\n", + "The following experiments were executed on a single `a10g` gpu `g5.8xlarge` AWS instance for consistency. With `deepspeed_stage_2_offload`" ] }, { @@ -34,9 +38,9 @@ "metadata": {}, "source": [ "## Install the nightly build within conda\n", - "(Skip if you already have 2.0.2, or already done the setup)\n", + "(Skip if you already have 2.1.0, or already done the setup)\n", "\n", - "For torch.compile, as of 8th July 2023, you will need the torch nightly build for several fixes we depend on. This is expected to be resolved when merged in for torch 2.0.2 (you will need to call this outside the notebook)\n", + "For torch.compile, as of 8th July 2023, you will need the torch nightly build for several fixes we depend on. This is expected to be resolved when merged in for torch 2.1.0 release (you will need to perform this setup outside the notebook)\n", "\n", "```bash\n", "conda activate rwkv-infctx\n", @@ -59,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -67,8 +71,8 @@ "output_type": "stream", "text": [ "DEEPSPEED_STRAT: deepspeed_stage_2_offload\n", - "GPU_DEVICES: auto\n", - "ENABLE_WANDB: False\n" + "ENABLE_WANDB: False\n", + "GPU_DEVICES: auto\n" ] } ], @@ -87,7 +91,7 @@ " WANDB_MODE=\"disabled\"\n", "\n", "# Ensure logs dir is initialized\n", - "!mkdir -p /logs/" + "!mkdir -p ./logs/" ] }, { @@ -959,7 +963,238 @@ "Epoch 0: 58%|█████▊ | 767/1315 [18:50<13:27, 1.47s/it, v_num=61me, train/loss=6.910]\n", "Epoch 0: 58%|█████▊ | 768/1315 [18:52<13:26, 1.47s/it, v_num=61me, train/loss=7.310]\n", "Epoch 0: 58%|█████▊ | 769/1315 [18:53<13:24, 1.47s/it, v_num=61me, train/loss=7.030]\n", - "Epoch 0: 59%|█████▊ | 770/1315 [18:56<13:24, 1.48s/it, v_num=61me, train/loss=7.060]\n" + "Epoch 0: 59%|█████▊ | 770/1315 [18:56<13:24, 1.48s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 59%|█████▊ | 771/1315 [18:57<13:22, 1.48s/it, v_num=61me, train/loss=7.190]\n", + "Epoch 0: 59%|█████▊ | 772/1315 [18:58<13:21, 1.48s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 59%|█████▉ | 773/1315 [19:00<13:19, 1.48s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 59%|█████▉ | 774/1315 [19:01<13:17, 1.47s/it, v_num=61me, train/loss=7.190]\n", + "Epoch 0: 59%|█████▉ | 775/1315 [19:02<13:16, 1.47s/it, v_num=61me, train/loss=7.250]\n", + "Epoch 0: 59%|█████▉ | 776/1315 [19:03<13:14, 1.47s/it, v_num=61me, train/loss=7.470]\n", + "Epoch 0: 59%|█████▉ | 777/1315 [19:05<13:12, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 59%|█████▉ | 778/1315 [19:06<13:11, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 59%|█████▉ | 779/1315 [19:07<13:09, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 59%|█████▉ | 780/1315 [19:10<13:09, 1.48s/it, v_num=61me, train/loss=7.220]\n", + "Epoch 0: 59%|█████▉ | 781/1315 [19:11<13:07, 1.48s/it, v_num=61me, train/loss=7.220]\n", + "Epoch 0: 59%|█████▉ | 782/1315 [19:13<13:06, 1.47s/it, v_num=61me, train/loss=7.690]\n", + "Epoch 0: 60%|█████▉ | 783/1315 [19:14<13:04, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 60%|█████▉ | 784/1315 [19:15<13:02, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 60%|█████▉ | 785/1315 [19:17<13:01, 1.47s/it, v_num=61me, train/loss=7.190]\n", + "Epoch 0: 60%|█████▉ | 786/1315 [19:18<12:59, 1.47s/it, v_num=61me, train/loss=7.530]\n", + "Epoch 0: 60%|█████▉ | 787/1315 [19:19<12:57, 1.47s/it, v_num=61me, train/loss=7.220]\n", + "Epoch 0: 60%|█████▉ | 788/1315 [19:20<12:56, 1.47s/it, v_num=61me, train/loss=7.220]\n", + "Epoch 0: 60%|██████ | 789/1315 [19:22<12:54, 1.47s/it, v_num=61me, train/loss=7.190]\n", + "Epoch 0: 60%|██████ | 790/1315 [19:25<12:54, 1.47s/it, v_num=61me, train/loss=7.380]\n", + "Epoch 0: 60%|██████ | 791/1315 [19:26<12:52, 1.47s/it, v_num=61me, train/loss=7.310]\n", + "Epoch 0: 60%|██████ | 792/1315 [19:27<12:51, 1.47s/it, v_num=61me, train/loss=7.690]\n", + "Epoch 0: 60%|██████ | 793/1315 [19:28<12:49, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 60%|██████ | 794/1315 [19:30<12:47, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 60%|██████ | 795/1315 [19:31<12:46, 1.47s/it, v_num=61me, train/loss=7.030]\n", + "Epoch 0: 61%|██████ | 796/1315 [19:32<12:44, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 61%|██████ | 797/1315 [19:33<12:42, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 61%|██████ | 798/1315 [19:35<12:41, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 61%|██████ | 799/1315 [19:36<12:39, 1.47s/it, v_num=61me, train/loss=7.280]\n", + "Epoch 0: 61%|██████ | 800/1315 [19:39<12:39, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 61%|██████ | 801/1315 [19:40<12:37, 1.47s/it, v_num=61me, train/loss=7.310]\n", + "Epoch 0: 61%|██████ | 802/1315 [19:41<12:36, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 61%|██████ | 803/1315 [19:43<12:34, 1.47s/it, v_num=61me, train/loss=7.160]\n", + "Epoch 0: 61%|██████ | 804/1315 [19:44<12:32, 1.47s/it, v_num=61me, train/loss=7.190]\n", + "Epoch 0: 61%|██████ | 805/1315 [19:45<12:31, 1.47s/it, v_num=61me, train/loss=7.190]\n", + "Epoch 0: 61%|██████▏ | 806/1315 [19:47<12:29, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 61%|██████▏ | 807/1315 [19:48<12:28, 1.47s/it, v_num=61me, train/loss=7.250]\n", + "Epoch 0: 61%|██████▏ | 808/1315 [19:49<12:26, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 62%|██████▏ | 809/1315 [19:50<12:24, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 62%|██████▏ | 810/1315 [19:53<12:24, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 62%|██████▏ | 811/1315 [19:55<12:22, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 62%|██████▏ | 812/1315 [19:56<12:21, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 62%|██████▏ | 813/1315 [19:57<12:19, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 62%|██████▏ | 814/1315 [19:58<12:17, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 62%|██████▏ | 815/1315 [20:00<12:16, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 62%|██████▏ | 816/1315 [20:01<12:14, 1.47s/it, v_num=61me, train/loss=7.470]\n", + "Epoch 0: 62%|██████▏ | 817/1315 [20:02<12:13, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 62%|██████▏ | 818/1315 [20:03<12:11, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 62%|██████▏ | 819/1315 [20:05<12:09, 1.47s/it, v_num=61me, train/loss=7.220]\n", + "Epoch 0: 62%|██████▏ | 820/1315 [20:08<12:09, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 62%|██████▏ | 821/1315 [20:09<12:07, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 63%|██████▎ | 822/1315 [20:10<12:06, 1.47s/it, v_num=61me, train/loss=7.160]\n", + "Epoch 0: 63%|██████▎ | 823/1315 [20:11<12:04, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 63%|██████▎ | 824/1315 [20:13<12:02, 1.47s/it, v_num=61me, train/loss=7.250]\n", + "Epoch 0: 63%|██████▎ | 825/1315 [20:14<12:01, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 63%|██████▎ | 826/1315 [20:15<11:59, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 63%|██████▎ | 827/1315 [20:16<11:58, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 63%|██████▎ | 828/1315 [20:18<11:56, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 63%|██████▎ | 829/1315 [20:19<11:54, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 63%|██████▎ | 830/1315 [20:22<11:54, 1.47s/it, v_num=61me, train/loss=6.720]\n", + "Epoch 0: 63%|██████▎ | 831/1315 [20:23<11:52, 1.47s/it, v_num=61me, train/loss=7.250]\n", + "Epoch 0: 63%|██████▎ | 832/1315 [20:25<11:51, 1.47s/it, v_num=61me, train/loss=7.250]\n", + "Epoch 0: 63%|██████▎ | 833/1315 [20:26<11:49, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 63%|██████▎ | 834/1315 [20:27<11:47, 1.47s/it, v_num=61me, train/loss=7.310]\n", + "Epoch 0: 63%|██████▎ | 835/1315 [20:28<11:46, 1.47s/it, v_num=61me, train/loss=6.910]\n", + "Epoch 0: 64%|██████▎ | 836/1315 [20:30<11:44, 1.47s/it, v_num=61me, train/loss=7.030]\n", + "Epoch 0: 64%|██████▎ | 837/1315 [20:31<11:43, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 64%|██████▎ | 838/1315 [20:32<11:41, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 64%|██████▍ | 839/1315 [20:33<11:40, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 64%|██████▍ | 840/1315 [20:36<11:39, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 64%|██████▍ | 841/1315 [20:38<11:37, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 64%|██████▍ | 842/1315 [20:39<11:36, 1.47s/it, v_num=61me, train/loss=7.280]\n", + "Epoch 0: 64%|██████▍ | 843/1315 [20:40<11:34, 1.47s/it, v_num=61me, train/loss=7.500]\n", + "Epoch 0: 64%|██████▍ | 844/1315 [20:41<11:33, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 64%|██████▍ | 845/1315 [20:43<11:31, 1.47s/it, v_num=61me, train/loss=7.030]\n", + "Epoch 0: 64%|██████▍ | 846/1315 [20:44<11:29, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 64%|██████▍ | 847/1315 [20:45<11:28, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 64%|██████▍ | 848/1315 [20:46<11:26, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 65%|██████▍ | 849/1315 [20:48<11:25, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 65%|██████▍ | 850/1315 [20:51<11:24, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 65%|██████▍ | 851/1315 [20:52<11:22, 1.47s/it, v_num=61me, train/loss=7.030]\n", + "Epoch 0: 65%|██████▍ | 852/1315 [20:53<11:21, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 65%|██████▍ | 853/1315 [20:54<11:19, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 65%|██████▍ | 854/1315 [20:56<11:18, 1.47s/it, v_num=61me, train/loss=7.410]\n", + "Epoch 0: 65%|██████▌ | 855/1315 [20:57<11:16, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 65%|██████▌ | 856/1315 [20:58<11:14, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 65%|██████▌ | 857/1315 [21:00<11:13, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 65%|██████▌ | 858/1315 [21:01<11:11, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 65%|██████▌ | 859/1315 [21:02<11:10, 1.47s/it, v_num=61me, train/loss=7.030]\n", + "Epoch 0: 65%|██████▌ | 860/1315 [21:05<11:09, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 65%|██████▌ | 861/1315 [21:06<11:07, 1.47s/it, v_num=61me, train/loss=6.590]\n", + "Epoch 0: 66%|██████▌ | 862/1315 [21:08<11:06, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 66%|██████▌ | 863/1315 [21:09<11:04, 1.47s/it, v_num=61me, train/loss=7.220]\n", + "Epoch 0: 66%|██████▌ | 864/1315 [21:10<11:03, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 66%|██████▌ | 865/1315 [21:11<11:01, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 66%|██████▌ | 866/1315 [21:13<11:00, 1.47s/it, v_num=61me, train/loss=7.470]\n", + "Epoch 0: 66%|██████▌ | 867/1315 [21:14<10:58, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 66%|██████▌ | 868/1315 [21:15<10:56, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 66%|██████▌ | 869/1315 [21:16<10:55, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 66%|██████▌ | 870/1315 [21:19<10:54, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 66%|██████▌ | 871/1315 [21:21<10:53, 1.47s/it, v_num=61me, train/loss=7.190]\n", + "Epoch 0: 66%|██████▋ | 872/1315 [21:22<10:51, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 66%|██████▋ | 873/1315 [21:23<10:49, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 66%|██████▋ | 874/1315 [21:24<10:48, 1.47s/it, v_num=61me, train/loss=6.910]\n", + "Epoch 0: 67%|██████▋ | 875/1315 [21:26<10:46, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 67%|██████▋ | 876/1315 [21:27<10:45, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 67%|██████▋ | 877/1315 [21:28<10:43, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 67%|██████▋ | 878/1315 [21:29<10:42, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 67%|██████▋ | 879/1315 [21:31<10:40, 1.47s/it, v_num=61me, train/loss=6.690]\n", + "Epoch 0: 67%|██████▋ | 880/1315 [21:34<10:39, 1.47s/it, v_num=61me, train/loss=7.250]\n", + "Epoch 0: 67%|██████▋ | 881/1315 [21:35<10:38, 1.47s/it, v_num=61me, train/loss=6.910]\n", + "Epoch 0: 67%|██████▋ | 882/1315 [21:36<10:36, 1.47s/it, v_num=61me, train/loss=6.620]\n", + "Epoch 0: 67%|██████▋ | 883/1315 [21:38<10:35, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 67%|██████▋ | 884/1315 [21:39<10:33, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 67%|██████▋ | 885/1315 [21:40<10:31, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 67%|██████▋ | 886/1315 [21:41<10:30, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 67%|██████▋ | 887/1315 [21:43<10:28, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 68%|██████▊ | 888/1315 [21:44<10:27, 1.47s/it, v_num=61me, train/loss=7.220]\n", + "Epoch 0: 68%|██████▊ | 889/1315 [21:45<10:25, 1.47s/it, v_num=61me, train/loss=7.220]\n", + "Epoch 0: 68%|██████▊ | 890/1315 [21:48<10:24, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 68%|██████▊ | 891/1315 [21:49<10:23, 1.47s/it, v_num=61me, train/loss=7.310]\n", + "Epoch 0: 68%|██████▊ | 892/1315 [21:51<10:21, 1.47s/it, v_num=61me, train/loss=7.410]\n", + "Epoch 0: 68%|██████▊ | 893/1315 [21:52<10:20, 1.47s/it, v_num=61me, train/loss=6.660]\n", + "Epoch 0: 68%|██████▊ | 894/1315 [21:53<10:18, 1.47s/it, v_num=61me, train/loss=7.310]\n", + "Epoch 0: 68%|██████▊ | 895/1315 [21:54<10:17, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 68%|██████▊ | 896/1315 [21:56<10:15, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 68%|██████▊ | 897/1315 [21:57<10:13, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 68%|██████▊ | 898/1315 [21:58<10:12, 1.47s/it, v_num=61me, train/loss=7.310]\n", + "Epoch 0: 68%|██████▊ | 899/1315 [21:59<10:10, 1.47s/it, v_num=61me, train/loss=6.910]\n", + "Epoch 0: 68%|██████▊ | 900/1315 [22:03<10:10, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 69%|██████▊ | 901/1315 [22:04<10:08, 1.47s/it, v_num=61me, train/loss=7.030]\n", + "Epoch 0: 69%|██████▊ | 902/1315 [22:05<10:06, 1.47s/it, v_num=61me, train/loss=7.030]\n", + "Epoch 0: 69%|██████▊ | 903/1315 [22:06<10:05, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 69%|██████▊ | 904/1315 [22:07<10:03, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 69%|██████▉ | 905/1315 [22:09<10:02, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 69%|██████▉ | 906/1315 [22:10<10:00, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 69%|██████▉ | 907/1315 [22:11<09:59, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 69%|██████▉ | 908/1315 [22:13<09:57, 1.47s/it, v_num=61me, train/loss=7.380]\n", + "Epoch 0: 69%|██████▉ | 909/1315 [22:14<09:55, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 69%|██████▉ | 910/1315 [22:17<09:55, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 69%|██████▉ | 911/1315 [22:18<09:53, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 69%|██████▉ | 912/1315 [22:19<09:52, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 69%|██████▉ | 913/1315 [22:21<09:50, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 70%|██████▉ | 914/1315 [22:22<09:48, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 70%|██████▉ | 915/1315 [22:23<09:47, 1.47s/it, v_num=61me, train/loss=6.910]\n", + "Epoch 0: 70%|██████▉ | 916/1315 [22:24<09:45, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 70%|██████▉ | 917/1315 [22:26<09:44, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 70%|██████▉ | 918/1315 [22:27<09:42, 1.47s/it, v_num=61me, train/loss=7.910]\n", + "Epoch 0: 70%|██████▉ | 919/1315 [22:28<09:41, 1.47s/it, v_num=61me, train/loss=7.250]\n", + "Epoch 0: 70%|██████▉ | 920/1315 [22:31<09:40, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 70%|███████ | 921/1315 [22:32<09:38, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 70%|███████ | 922/1315 [22:34<09:37, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 70%|███████ | 923/1315 [22:35<09:35, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 70%|███████ | 924/1315 [22:36<09:34, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 70%|███████ | 925/1315 [22:37<09:32, 1.47s/it, v_num=61me, train/loss=7.030]\n", + "Epoch 0: 70%|███████ | 926/1315 [22:39<09:30, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 70%|███████ | 927/1315 [22:40<09:29, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 71%|███████ | 928/1315 [22:41<09:27, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 71%|███████ | 929/1315 [22:43<09:26, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 71%|███████ | 930/1315 [22:46<09:25, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 71%|███████ | 931/1315 [22:47<09:23, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 71%|███████ | 932/1315 [22:48<09:22, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 71%|███████ | 933/1315 [22:49<09:20, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 71%|███████ | 934/1315 [22:51<09:19, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 71%|███████ | 935/1315 [22:52<09:17, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 71%|███████ | 936/1315 [22:53<09:16, 1.47s/it, v_num=61me, train/loss=6.690]\n", + "Epoch 0: 71%|███████▏ | 937/1315 [22:54<09:14, 1.47s/it, v_num=61me, train/loss=6.620]\n", + "Epoch 0: 71%|███████▏ | 938/1315 [22:56<09:13, 1.47s/it, v_num=61me, train/loss=7.160]\n", + "Epoch 0: 71%|███████▏ | 939/1315 [22:57<09:11, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 71%|███████▏ | 940/1315 [23:00<09:10, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 72%|███████▏ | 941/1315 [23:01<09:09, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 72%|███████▏ | 942/1315 [23:02<09:07, 1.47s/it, v_num=61me, train/loss=7.380]\n", + "Epoch 0: 72%|███████▏ | 943/1315 [23:04<09:06, 1.47s/it, v_num=61me, train/loss=6.620]\n", + "Epoch 0: 72%|███████▏ | 944/1315 [23:05<09:04, 1.47s/it, v_num=61me, train/loss=7.060]\n", + "Epoch 0: 72%|███████▏ | 945/1315 [23:06<09:02, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 72%|███████▏ | 946/1315 [23:07<09:01, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 72%|███████▏ | 947/1315 [23:09<08:59, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 72%|███████▏ | 948/1315 [23:10<08:58, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 72%|███████▏ | 949/1315 [23:11<08:56, 1.47s/it, v_num=61me, train/loss=7.120]\n", + "Epoch 0: 72%|███████▏ | 950/1315 [23:14<08:55, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 72%|███████▏ | 951/1315 [23:15<08:54, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 72%|███████▏ | 952/1315 [23:17<08:52, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 72%|███████▏ | 953/1315 [23:18<08:51, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 73%|███████▎ | 954/1315 [23:19<08:49, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 73%|███████▎ | 955/1315 [23:20<08:48, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 73%|███████▎ | 956/1315 [23:22<08:46, 1.47s/it, v_num=61me, train/loss=6.440]\n", + "Epoch 0: 73%|███████▎ | 957/1315 [23:23<08:45, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 73%|███████▎ | 958/1315 [23:24<08:43, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 73%|███████▎ | 959/1315 [23:26<08:41, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 73%|███████▎ | 960/1315 [23:29<08:41, 1.47s/it, v_num=61me, train/loss=6.660]\n", + "Epoch 0: 73%|███████▎ | 961/1315 [23:30<08:39, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 73%|███████▎ | 962/1315 [23:31<08:37, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 73%|███████▎ | 963/1315 [23:32<08:36, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 73%|███████▎ | 964/1315 [23:34<08:34, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 73%|███████▎ | 965/1315 [23:35<08:33, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 73%|███████▎ | 966/1315 [23:36<08:31, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 74%|███████▎ | 967/1315 [23:37<08:30, 1.47s/it, v_num=61me, train/loss=6.620]\n", + "Epoch 0: 74%|███████▎ | 968/1315 [23:39<08:28, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 74%|███████▎ | 969/1315 [23:40<08:27, 1.47s/it, v_num=61me, train/loss=6.690]\n", + "Epoch 0: 74%|███████▍ | 970/1315 [23:43<08:26, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 74%|███████▍ | 971/1315 [23:44<08:24, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 74%|███████▍ | 972/1315 [23:45<08:23, 1.47s/it, v_num=61me, train/loss=6.910]\n", + "Epoch 0: 74%|███████▍ | 973/1315 [23:47<08:21, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 74%|███████▍ | 974/1315 [23:48<08:20, 1.47s/it, v_num=61me, train/loss=6.620]\n", + "Epoch 0: 74%|███████▍ | 975/1315 [23:49<08:18, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 74%|███████▍ | 976/1315 [23:50<08:17, 1.47s/it, v_num=61me, train/loss=7.160]\n", + "Epoch 0: 74%|███████▍ | 977/1315 [23:52<08:15, 1.47s/it, v_num=61me, train/loss=6.910]\n", + "Epoch 0: 74%|███████▍ | 978/1315 [23:53<08:13, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 74%|███████▍ | 979/1315 [23:54<08:12, 1.47s/it, v_num=61me, train/loss=6.590]\n", + "Epoch 0: 75%|███████▍ | 980/1315 [23:57<08:11, 1.47s/it, v_num=61me, train/loss=6.660]\n", + "Epoch 0: 75%|███████▍ | 981/1315 [23:58<08:09, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 75%|███████▍ | 982/1315 [24:00<08:08, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 75%|███████▍ | 983/1315 [24:01<08:06, 1.47s/it, v_num=61me, train/loss=6.690]\n", + "Epoch 0: 75%|███████▍ | 984/1315 [24:02<08:05, 1.47s/it, v_num=61me, train/loss=6.970]\n", + "Epoch 0: 75%|███████▍ | 985/1315 [24:04<08:03, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 75%|███████▍ | 986/1315 [24:05<08:02, 1.47s/it, v_num=61me, train/loss=6.880]\n", + "Epoch 0: 75%|███████▌ | 987/1315 [24:06<08:00, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 75%|███████▌ | 988/1315 [24:07<07:59, 1.47s/it, v_num=61me, train/loss=6.810]\n", + "Epoch 0: 75%|███████▌ | 989/1315 [24:09<07:57, 1.47s/it, v_num=61me, train/loss=6.500]\n", + "Epoch 0: 75%|███████▌ | 990/1315 [24:12<07:56, 1.47s/it, v_num=61me, train/loss=6.940]\n", + "Epoch 0: 75%|███████▌ | 991/1315 [24:13<07:55, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 75%|███████▌ | 992/1315 [24:14<07:53, 1.47s/it, v_num=61me, train/loss=6.910]\n", + "Epoch 0: 76%|███████▌ | 993/1315 [24:15<07:52, 1.47s/it, v_num=61me, train/loss=6.690]\n", + "Epoch 0: 76%|███████▌ | 994/1315 [24:17<07:50, 1.47s/it, v_num=61me, train/loss=7.000]\n", + "Epoch 0: 76%|███████▌ | 995/1315 [24:18<07:49, 1.47s/it, v_num=61me, train/loss=6.840]\n", + "Epoch 0: 76%|███████▌ | 996/1315 [24:19<07:47, 1.47s/it, v_num=61me, train/loss=6.750]\n", + "Epoch 0: 76%|███████▌ | 997/1315 [24:20<07:45, 1.47s/it, v_num=61me, train/loss=7.090]\n", + "Epoch 0: 76%|███████▌ | 998/1315 [24:22<07:44, 1.47s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 76%|███████▌ | 999/1315 [24:23<07:42, 1.46s/it, v_num=61me, train/loss=6.780]\n", + "Epoch 0: 76%|███████▌ | 1000/1315 [24:26<07:41, 1.47s/it, v_num=61me, train/loss=6.620]`Trainer.fit` stopped: `max_steps=100` reached.\n", + "Epoch 0: 76%|███████▌ | 1000/1315 [24:26<07:41, 1.47s/it, v_num=61me, train/loss=6.620]\n" ] } ], @@ -987,9 +1222,1069 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-07-08 07:01:31,337] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[RWKV.model] Running RWKV model via the following optimization mode : torch-jit\n", + "Global seed set to 3941088705\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_4096_bf16/build.ninja...\n", + "Building extension module wkv_4096_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module wkv_4096_bf16...\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|███████████████████████████████████████████| 1/1 [00:00<00:00, 1000.79it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-a9b10ddaafcd70a8_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-cfd32fc41583b797_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f22a54fa61543287_*_of_00032.arrow\n", + "[rank: 0] Global seed set to 3941088705 \n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[2023-07-08 07:01:45,403] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-08 07:01:45,404] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "Enabling DeepSpeed BF16.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096)\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module cpu_adam...\n", + "Time to load cpu_adam op: 2.3308887481689453 seconds\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "Epoch 0: 0%| | 0/1315 [00:00=1.0.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.1.0)\n", + "Requirement already satisfied: cycler>=0.10 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (0.11.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (4.40.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.4.4)\n", + "Requirement already satisfied: numpy>=1.20 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.25.0)\n", + "Requirement already satisfied: packaging>=20.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (22.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (9.3.0)\n", + "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: six>=1.5 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n" + ] + } + ], + "source": [ + "# Install matlab plotting library\n", + "!python3 -m pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last step figures ...\n", + "Baseline: {'it': 1000, 'time': 461, 's_time': '07:41', 'loss': 6.62}\n", + "JIT: {'it': 1000, 'time': 443, 's_time': '07:23', 'loss': 6.66}\n", + "Torch Compile: {'it': 1000, 'time': 451, 's_time': '07:31', 'loss': 6.69}\n" + ] + } + ], + "source": [ + "# First we need to extract the numbers from the logs\n", + "import re\n", + "\n", + "def convert_time_to_seconds(time_str):\n", + " t = list(map(int, time_str.split(':')))\n", + " return sum([a*b for (a,b) in zip(t[::-1], (1, 60, 3600))])\n", + "\n", + "def extract_from_training_logs(log_file):\n", + " result = []\n", + " with open(log_file, 'r') as file:\n", + " for line in file.readlines():\n", + " # Check if the line starts with \"Epoch 0:\"\n", + " if line.startswith(\"Epoch 0:\"):\n", + " iteration = re.search(r'(?<=\\| )(\\d+)', line) # Extracts the iteration number\n", + " time_spent = re.search(r'(?<=\\[\\d\\d:\\d\\d<)(.*?)(?=\\,)', line) # Extracts the time spent so far\n", + " loss = re.search(r'(?<=train/loss=)(\\d+.\\d+)', line) # Extracts the train/loss number\n", + " \n", + " if iteration and time_spent and loss:\n", + " result.append({\n", + " \"it\": int(iteration.group(0)), \n", + " \"time\": convert_time_to_seconds(time_spent.group(0)),\n", + " \"s_time\": time_spent.group(0),\n", + " \"loss\": float(loss.group(0))\n", + " })\n", + " return result\n", + "\n", + "\n", + "# Extract the numbers\n", + "step_baseline = extract_from_training_logs(\"./logs/torch-compile-perf_baseline.log\")\n", + "step_jit = extract_from_training_logs(\"./logs/torch-compile-perf_jit.log\")\n", + "step_tcompile = extract_from_training_logs(\"./logs/torch-compile-perf_torch-compile.log\")\n", + "\n", + "# Print the high level numbers\n", + "print(\"Last step figures ...\")\n", + "print(\"Baseline: \", step_baseline[-1])\n", + "print(\"JIT: \", step_jit[-1])\n", + "print(\"Torch Compile: \", step_tcompile[-1])" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Check if the loss plot is similar\n", + "\n", + "No point having a faster JIT / torch.compile, if the loss curve does not fall at the same rate" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the loss curve\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Extract iteration and loss values for each method\n", + "it_baseline = [entry['it'] for entry in step_baseline]\n", + "loss_baseline = [entry['loss'] for entry in step_baseline]\n", + "\n", + "it_jit = [entry['it'] for entry in step_jit]\n", + "loss_jit = [entry['loss'] for entry in step_jit]\n", + "\n", + "it_tcompile = [entry['it'] for entry in step_tcompile]\n", + "loss_tcompile = [entry['loss'] for entry in step_tcompile]\n", + "\n", + "# Plot loss curves\n", + "plt.plot(it_baseline, loss_baseline, label=\"Baseline\", linestyle='-')\n", + "plt.plot(it_jit, loss_jit, label=\"JIT\", linestyle='--')\n", + "plt.plot(it_tcompile, loss_tcompile, label=\"TCompile\", linestyle='-.')\n", + "\n", + "plt.xlabel('Iteration step')\n", + "plt.ylabel('Loss')\n", + "plt.title('Loss Curve')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working as designed, it should be nearly impossible to see the differences between the 3 lines. So lets plot the delta against baseline instead." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "'--.' is not a valid value for ls; supported values are '-', '--', '-.', ':', 'None', ' ', '', 'solid', 'dashed', 'dashdot', 'dotted'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[66], line 14\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[39m# Plot deltas\u001b[39;00m\n\u001b[1;32m 13\u001b[0m plt\u001b[39m.\u001b[39mplot(it_jit, delta_jit_baseline, label\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mJIT - Baseline\u001b[39m\u001b[39m\"\u001b[39m, linestyle\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39m-\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m---> 14\u001b[0m plt\u001b[39m.\u001b[39;49mplot(it_tcompile, delta_tcompile_baseline, label\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mTCompile - Baseline\u001b[39;49m\u001b[39m\"\u001b[39;49m, linestyle\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39m--.\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[1;32m 16\u001b[0m plt\u001b[39m.\u001b[39mxlabel(\u001b[39m'\u001b[39m\u001b[39mIteration step\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 17\u001b[0m plt\u001b[39m.\u001b[39mylabel(\u001b[39m'\u001b[39m\u001b[39mDelta Loss\u001b[39m\u001b[39m'\u001b[39m)\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/pyplot.py:2812\u001b[0m, in \u001b[0;36mplot\u001b[0;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2810\u001b[0m \u001b[39m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[39m.\u001b[39mplot)\n\u001b[1;32m 2811\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mplot\u001b[39m(\u001b[39m*\u001b[39margs, scalex\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, scaley\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m-> 2812\u001b[0m \u001b[39mreturn\u001b[39;00m gca()\u001b[39m.\u001b[39;49mplot(\n\u001b[1;32m 2813\u001b[0m \u001b[39m*\u001b[39;49margs, scalex\u001b[39m=\u001b[39;49mscalex, scaley\u001b[39m=\u001b[39;49mscaley,\n\u001b[1;32m 2814\u001b[0m \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49m({\u001b[39m\"\u001b[39;49m\u001b[39mdata\u001b[39;49m\u001b[39m\"\u001b[39;49m: data} \u001b[39mif\u001b[39;49;00m data \u001b[39mis\u001b[39;49;00m \u001b[39mnot\u001b[39;49;00m \u001b[39mNone\u001b[39;49;00m \u001b[39melse\u001b[39;49;00m {}), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_axes.py:1688\u001b[0m, in \u001b[0;36mAxes.plot\u001b[0;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1446\u001b[0m \u001b[39mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[1;32m 1447\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1685\u001b[0m \u001b[39m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[1;32m 1686\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1687\u001b[0m kwargs \u001b[39m=\u001b[39m cbook\u001b[39m.\u001b[39mnormalize_kwargs(kwargs, mlines\u001b[39m.\u001b[39mLine2D)\n\u001b[0;32m-> 1688\u001b[0m lines \u001b[39m=\u001b[39m [\u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_lines(\u001b[39m*\u001b[39margs, data\u001b[39m=\u001b[39mdata, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)]\n\u001b[1;32m 1689\u001b[0m \u001b[39mfor\u001b[39;00m line \u001b[39min\u001b[39;00m lines:\n\u001b[1;32m 1690\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39madd_line(line)\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:311\u001b[0m, in \u001b[0;36m_process_plot_var_args.__call__\u001b[0;34m(self, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m this \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m args[\u001b[39m0\u001b[39m],\n\u001b[1;32m 310\u001b[0m args \u001b[39m=\u001b[39m args[\u001b[39m1\u001b[39m:]\n\u001b[0;32m--> 311\u001b[0m \u001b[39myield from\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_plot_args(\n\u001b[1;32m 312\u001b[0m this, kwargs, ambiguous_fmt_datakey\u001b[39m=\u001b[39;49mambiguous_fmt_datakey)\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:544\u001b[0m, in \u001b[0;36m_process_plot_var_args._plot_args\u001b[0;34m(self, tup, kwargs, return_kwargs, ambiguous_fmt_datakey)\u001b[0m\n\u001b[1;32m 542\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mlist\u001b[39m(result)\n\u001b[1;32m 543\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 544\u001b[0m \u001b[39mreturn\u001b[39;00m [l[\u001b[39m0\u001b[39;49m] \u001b[39mfor\u001b[39;49;00m l \u001b[39min\u001b[39;49;00m result]\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:544\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 542\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mlist\u001b[39m(result)\n\u001b[1;32m 543\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 544\u001b[0m \u001b[39mreturn\u001b[39;00m [l[\u001b[39m0\u001b[39m] \u001b[39mfor\u001b[39;00m l \u001b[39min\u001b[39;00m result]\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:537\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 535\u001b[0m labels \u001b[39m=\u001b[39m [label] \u001b[39m*\u001b[39m n_datasets\n\u001b[0;32m--> 537\u001b[0m result \u001b[39m=\u001b[39m (make_artist(x[:, j \u001b[39m%\u001b[39;49m ncx], y[:, j \u001b[39m%\u001b[39;49m ncy], kw,\n\u001b[1;32m 538\u001b[0m {\u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs, \u001b[39m'\u001b[39;49m\u001b[39mlabel\u001b[39;49m\u001b[39m'\u001b[39;49m: label})\n\u001b[1;32m 539\u001b[0m \u001b[39mfor\u001b[39;00m j, label \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(labels))\n\u001b[1;32m 541\u001b[0m \u001b[39mif\u001b[39;00m return_kwargs:\n\u001b[1;32m 542\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mlist\u001b[39m(result)\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:351\u001b[0m, in \u001b[0;36m_process_plot_var_args._makeline\u001b[0;34m(self, x, y, kw, kwargs)\u001b[0m\n\u001b[1;32m 349\u001b[0m default_dict \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_getdefaults(\u001b[39mset\u001b[39m(), kw)\n\u001b[1;32m 350\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_setdefaults(default_dict, kw)\n\u001b[0;32m--> 351\u001b[0m seg \u001b[39m=\u001b[39m mlines\u001b[39m.\u001b[39;49mLine2D(x, y, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkw)\n\u001b[1;32m 352\u001b[0m \u001b[39mreturn\u001b[39;00m seg, kw\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:454\u001b[0m, in \u001b[0;36mmake_keyword_only..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 448\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(args) \u001b[39m>\u001b[39m name_idx:\n\u001b[1;32m 449\u001b[0m warn_deprecated(\n\u001b[1;32m 450\u001b[0m since, message\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mPassing the \u001b[39m\u001b[39m%(name)s\u001b[39;00m\u001b[39m \u001b[39m\u001b[39m%(obj_type)s\u001b[39;00m\u001b[39m \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 451\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mpositionally is deprecated since Matplotlib \u001b[39m\u001b[39m%(since)s\u001b[39;00m\u001b[39m; the \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 452\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mparameter will become keyword-only \u001b[39m\u001b[39m%(removal)s\u001b[39;00m\u001b[39m.\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 453\u001b[0m name\u001b[39m=\u001b[39mname, obj_type\u001b[39m=\u001b[39m\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mparameter of \u001b[39m\u001b[39m{\u001b[39;00mfunc\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m()\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m--> 454\u001b[0m \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/lines.py:360\u001b[0m, in \u001b[0;36mLine2D.__init__\u001b[0;34m(self, xdata, ydata, linewidth, linestyle, color, gapcolor, marker, markersize, markeredgewidth, markeredgecolor, markerfacecolor, markerfacecoloralt, fillstyle, antialiased, dash_capstyle, solid_capstyle, dash_joinstyle, solid_joinstyle, pickradius, drawstyle, markevery, **kwargs)\u001b[0m\n\u001b[1;32m 357\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_dash_pattern \u001b[39m=\u001b[39m (\u001b[39m0\u001b[39m, \u001b[39mNone\u001b[39;00m) \u001b[39m# offset, dash (scaled by linewidth)\u001b[39;00m\n\u001b[1;32m 359\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mset_linewidth(linewidth)\n\u001b[0;32m--> 360\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mset_linestyle(linestyle)\n\u001b[1;32m 361\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mset_drawstyle(drawstyle)\n\u001b[1;32m 363\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_color \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/lines.py:1170\u001b[0m, in \u001b[0;36mLine2D.set_linestyle\u001b[0;34m(self, ls)\u001b[0m\n\u001b[1;32m 1168\u001b[0m \u001b[39mif\u001b[39;00m ls \u001b[39min\u001b[39;00m [\u001b[39m'\u001b[39m\u001b[39m \u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mnone\u001b[39m\u001b[39m'\u001b[39m]:\n\u001b[1;32m 1169\u001b[0m ls \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mNone\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m-> 1170\u001b[0m _api\u001b[39m.\u001b[39;49mcheck_in_list([\u001b[39m*\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_lineStyles, \u001b[39m*\u001b[39;49mls_mapper_r], ls\u001b[39m=\u001b[39;49mls)\n\u001b[1;32m 1171\u001b[0m \u001b[39mif\u001b[39;00m ls \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lineStyles:\n\u001b[1;32m 1172\u001b[0m ls \u001b[39m=\u001b[39m ls_mapper_r[ls]\n", + "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/_api/__init__.py:131\u001b[0m, in \u001b[0;36mcheck_in_list\u001b[0;34m(_values, _print_supported_values, **kwargs)\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[39mif\u001b[39;00m _print_supported_values:\n\u001b[1;32m 130\u001b[0m msg \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m; supported values are \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m, \u001b[39m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mjoin(\u001b[39mmap\u001b[39m(\u001b[39mrepr\u001b[39m,\u001b[39m \u001b[39mvalues))\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> 131\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(msg)\n", + "\u001b[0;31mValueError\u001b[0m: '--.' is not a valid value for ls; supported values are '-', '--', '-.', ':', 'None', ' ', '', 'solid', 'dashed', 'dashdot', 'dotted'" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA600lEQVR4nO3de1yUdf7//yeIDCgCIocRxWMmmGdIxNzckk+42ZblWvlzy8yP3fqs7Fr0cdMy3bZtadvNtLL89Nmsb580Wzu4aS67hKdMPKGpeEDzBKLDQeQsx7l+f7COToyoxUhcPu6329xuw/t6va/rdb0HmSfXzIiHYRiGAAAATMSzpRsAAABobgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOl4t3UBLsNvtOnXqlDp06CAPD4+WbgcAAFwBwzBUVlam8PBweXo2fY3mugw4p06dUkREREu3AQAAvoecnBx17dq1yZrrMuB06NBBUsMC+fv7t3A3AADgSpSWlioiIsLxPN6U6zLgnH9Zyt/fn4ADAEArcyVvL+FNxgAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOLgubDpcqJdTDup0ybmWbgXAdcAwDP2/zcf19sYjqqu3t3Q7V6XebuiNtYcV84cv9bftOS3dzvd2Xf41cVx/fvnOVklSYXm1Xv7FoBbuBoDZ7T9dqnmf75Mk9Q8P0Igbglu4oyu343iR/vKvQ5Kk336yR7feGCJrgE8Ld3X1uIKD68rJs1zBAeB+52rqHfcrLrrfGlR+p9/KmroW6uSHIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTIeAAAADTuSYBZ9GiRerRo4d8fHwUGxurbdu2NVm/YsUKRUZGysfHRwMGDNCaNWsa1Rw4cEB33323AgIC1L59e918883Kzs521ykAAIBWxO0B56OPPlJSUpLmzZunnTt3atCgQUpISFB+fr7L+s2bN2vixImaOnWqdu3apXHjxmncuHHKzMx01Bw5ckQjR45UZGSk1q9frz179ui5556Tj4+Pu08HAAC0Am4POPPnz9e0adM0ZcoU9evXT4sXL1a7du20ZMkSl/ULFy7UmDFjNHPmTEVFRemFF17Q0KFD9cYbbzhqnn32Wd155516+eWXNWTIEPXu3Vt33323QkND3X06AACgFXBrwKmpqVFGRobi4+MvHNDTU/Hx8UpPT3c5Jz093alekhISEhz1drtdX3zxhW688UYlJCQoNDRUsbGxWrly5SX7qK6uVmlpqdMNrdsnGSf1xtrDqqypa+lWvrfN3xbq5ZSDOlV8rqVbAeBGRRXVmv+vLKXuz2vpVlyqrqvXW+uP6PW0w3rlX1lal+X6FZbLqau36383HtV7Xx+TYRjN3OXV83LnzgsLC1VfX6+wsDCn8bCwMB08eNDlHJvN5rLeZrNJkvLz81VeXq6XXnpJf/jDH/SnP/1JKSkpuu+++7Ru3TqNGjWq0T6Tk5P1/PPPN9NZoaUVllfrqRW7JUldOvrq3iFdW7ij7+f/++tWSZKttErz7x/css0AcJv3Np/QgdMNv1gf+eOdauPp0cIdOdt4qFB/SnH9nHw1th0v0otrDkiSYnoEqX+XgB+8zx+i1X2Kym63S5LuuecePfnkkxo8eLBmzZqlu+66S4sXL3Y5Z/bs2SopKXHccnJyrmXLaGbnauod9yuq65uobB1yiipbugUAblRUUe24/2O4svFdzXUl/OKfzZU1Lf+z2a1XcIKDg9WmTRvl5TlflsvLy5PVanU5x2q1NlkfHBwsLy8v9evXz6kmKipKmzZtcrlPi8Uii8XyfU8DAAC0Mm69guPt7a3o6GilpaU5xux2u9LS0hQXF+dyTlxcnFO9JKWmpjrqvb29dfPNNysrK8up5tChQ+revXsznwEAAGiN3HoFR5KSkpI0efJkxcTEaNiwYVqwYIEqKio0ZcoUSdLDDz+sLl26KDk5WZI0Y8YMjRo1Sq+88orGjh2r5cuXa8eOHXr77bcd+5w5c6YeeOAB3XrrrbrtttuUkpKiVatWaf369e4+HQAA0Aq4PeA88MADKigo0Ny5c2Wz2TR48GClpKQ43kicnZ0tT88LF5JGjBihZcuWac6cOXrmmWfUp08frVy5Uv3793fU3HvvvVq8eLGSk5P1m9/8Rn379tUnn3yikSNHuvt0AABAK+D2gCNJiYmJSkxMdLnN1VWXCRMmaMKECU3u89FHH9Wjjz7aHO0BAACTaXWfogIAALgcAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADAdAg4AADCdaxJwFi1apB49esjHx0exsbHatm1bk/UrVqxQZGSkfHx8NGDAAK1Zs+aStY8//rg8PDy0YMGCZu4aAAC0Vm4POB999JGSkpI0b9487dy5U4MGDVJCQoLy8/Nd1m/evFkTJ07U1KlTtWvXLo0bN07jxo1TZmZmo9rPPvtMW7ZsUXh4uLtPAwAAtCJuDzjz58/XtGnTNGXKFPXr10+LFy9Wu3bttGTJEpf1Cxcu1JgxYzRz5kxFRUXphRde0NChQ/XGG2841eXm5urXv/61li5dqrZt27r7NAAAQCvi5c6d19TUKCMjQ7Nnz3aMeXp6Kj4+Xunp6S7npKenKykpyWksISFBK1eudHxtt9v10EMPaebMmbrpppsu20d1dbWqq6sdX5eWll7lmQBSZm6JVu05pfFDu+rGsA4t3c41ZxiG3tt8XHX1hh4d2VNtPD1auqWrsjP7rP61L08P3ByhnsHtXdZU1dbr1S8PacmmY4ro2E7z7r5Jo24M+cHHPlJQrhU7Tupn/a0aFBGonKJKLduWrdv6hmpYz6BLzvtoe7YO5ZXrnsHhGtg10GXNscIKLd1yQifPntPIPsH65fDujWo+23VSJ4vO6dGRPdXe0vBj352P5ycZJ3W6pOF47bwv/zRTXFmjJV8fV7/OHTSmf2eVV9dpyaZj6hbUTuOGdLns/KMF5frbjpNKuClMxedqlXH8rCaP6KGQDpYr6resqlZLNh1X5qkS9evsL0kK8G2rKbf0kIfH5dflSh9PSVry9TF5enjo54PC9X/pJ+Tv66UzFTW6e1C4bgoPcDnHbje05Otj8vDw0JQRPfT33bk6WXRODw7rpo+2Z6tzgK/GR3d12dOoG0Nktxva9G2hfjm8u748kKdzNfW6d2gXfZB+Qv27uD7mxQxJ/2/zcVXX1evRW3rKq43ztZH8siq9v/mEth8vcoz9fvU+PT6qt+4a2HKvsLg14BQWFqq+vl5hYWFO42FhYTp48KDLOTabzWW9zWZzfP2nP/1JXl5e+s1vfnNFfSQnJ+v555+/yu4BZ79aulPZRZXaeKhQ/5jxk5Zu55rLzC3V86v2S5IGdg1QbK9OLdzR1Zm8ZJvKquqUmVuiD/4z1mXN2oP5+p8NRyVJRwsrNHnJNh1/aewPPvasT/Zo+/Gz+jgjRzvm/IdeWL1f/9qfp79+dVSHX7zT5Zycoko9/cleSdKu7LP69Fe3uKx79rO92nzkjCQpZZ9Ncb07qXeIn2N7UUWNnvxotyTJGuCjCTERktz3eBaUVeupFQ3H69LRV/cO6XqZGdKH23L0WtphSVLWH8ZozZ7Tmp96SJL0074hCmzn3eT8Zz7bqy1Hi7R8e7aKK2slNYTVOXf1u6KeV+0+rVe/bDhe6v48x3hMj46XDJYXu5LH87w/rml47lu957S+ySl2jKdk2rRh5m0u5+zKOas/fHFAktQzuJ3j8dx6rEibvi2UJN16Y4hToEv+xwGt2WvT4g1HZBgNYxsOFWjfqYZf8L88kKftx89Kkl6ZMKjJng+eLtO8z/dJkm4KD9AtNwQ7bf+fDUf1zqZjTmOZuaXafORMiwacVvcpqoyMDC1cuFDvvffeFSVrSZo9e7ZKSkoct5ycHDd3CTPKLqqUJB04fX1eAaysqbvofn0LdvL9lFU19N/U4+eu89qbWyJJKiyvkdRwRUeSauuNS845V3uhl6b62v+d86msdq6tusR+Ktz0eF58vIrqK9tvaVWt435dveH0vVZVa7/s/P3/ftI+H24kKb+s+lLljVx8vItdaf9X8nh+17HCCqevT5ypvGTtxX2c+ff3kNQQJs+7eN0l6WhBw/6Ni1o6aCtz3M89e85xv95ouu+L16eiuvFaXc1aX0tuDTjBwcFq06aN8vLynMbz8vJktVpdzrFarU3Wf/XVV8rPz1e3bt3k5eUlLy8vnThxQk899ZR69Ojhcp8Wi0X+/v5ONwAAYF5uDTje3t6Kjo5WWlqaY8xutystLU1xcXEu58TFxTnVS1Jqaqqj/qGHHtKePXv0zTffOG7h4eGaOXOm/vnPf7rvZAAAQKvh1vfgSFJSUpImT56smJgYDRs2TAsWLFBFRYWmTJkiSXr44YfVpUsXJScnS5JmzJihUaNG6ZVXXtHYsWO1fPly7dixQ2+//bYkqVOnTurUyfm14rZt28pqtapv377uPh0AANAKuD3gPPDAAyooKNDcuXNls9k0ePBgpaSkON5InJ2dLU/PCxeSRowYoWXLlmnOnDl65pln1KdPH61cuVL9+/d3d6sAAMAk3B5wJCkxMVGJiYkut61fv77R2IQJEzRhwoQr3v/x48e/Z2cAAMCMWt2nqAAAAC6HgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEyHgAMAAEzHq6UbAJrT3pMl+mLvaf0iuotuCO3Q0u38KGTZyvTprpO6e1C4bgoPaOl2JElLt55Q6bk6PTqyhyxebWQYhv5vywmt3JUrX+82+kV0V907pKvT47nvVKlOnKnUoyN7qq7eriVfH1e/zh2UV1qtoooaSVLP4Paqqq3XmYoaTR3ZU5sOF2r3yWI9MqKH49hnKmo0felO5Zyt1PN336Qh3Trq5NlKLd2arcKy6ka9vr3xiHzattFDw7trRcZJFZRVa+rIntp8pFCrdp+Wl6eHeoX4KbJzB20/VqRfDu+ulEyb3lz/rabfdoPTsSVp4ZeHdaSgwvH1198WavORQo28IUQbDhXolhs6Ke1Avt7bfNxRc9BWpsRlO7XvVKkqa+o06sYQtbd4KdjPouLK2kY9L9+WrU935koe0g2hfo7xeZ/vU3FlreoNQ1/uz3OMT3lvu7w8PTSmv1XVdXZ17eirKKu/JsR01QdbTuizXbnac7JEN4Z1UG29XX3C/OTdxlNf7D2tLoG+ui0yVJK04/hZ7c0tcex3zspMfbDlhLp29FU7by+1t7SRT9s2kqSTZ8+pX2d/SdJb64845gx78UtV1NQ7vp68ZJt82npqaPeO+vrbQnl5esqQNLxXkKOmtKqu0Rp8vvuUbCVV8vCQ+oX7O8b3nCyRxctTfa0NPx8OnC7VlqNFjeZL0vvpx/Wv/TZJUnWdXSXnalVfb+hIQbmG9+qkwvJq1dYbTo/n3L9nqo2nhzJOnHWM5ZU2/r4qOdf4cRv9ynr1tXbQ2YpabT9epOG9Oqmddxv966LH6v+2nLiw37Iqx/2FaYfVwefCU/pBW1mj/dfbDcf9UyUX5n7+zSmX5+/YvvvC9he+2K/0o2d08uw5de3oK0lKP3KmyfkthYADU3ns/3bodEmV0o8U6u+JI1u6nR+FGct36aCtTCmZNm2YeVtLt6NjhRV69rNMSdKNYX4aHRWmg7Yyzf37PkfN19+e0agbQx2P5z/32XSssOFJJMzfoqKKWr2WdrjJ4/QKbq//WrpTkmQYztu+2HtaUsMT+zdz71DymoOOse/645qDkqSIoHb67cd7JEndO7VT4rJdLus3HCrQvlOlkqTnV+3XLTcEO21/9ctDTl9P+utWSdKidQ1P8os3HJErq/dc6O9vO066rJGk7KJKzfp0r+Prbcecn7y/e/zz6uyG0zEkKcTfoucuelz2n244r8P55Y6x42cq9e7Xxy/Zz0FbmcsnW0lKveiJ+7yLw40kZeU1zN19ssRp/MC/e2nKtuMN5771WOMAs/kKnpT/kWm75LaL1+Bi76efcDl+JY4UVDiFpU3fFjaq2XPROlwcbj/OuPT3xOW4Os7Fvjp8YXtO0bkmH+8fEwIOTOX0v38r+e4Pw+vZ+SeXE2cqW7iTBhXVF37bPv9kVvmdJzVJOldb73g8z4ebhvn1Kq1q/Nvvd5VfdJwzFTXqHODj2N95558gLt7/pVx8daeyunG/5333yfzi821Obdt4qLbeaDReWdN8x3N1RcuVrh191SfUT+uyCi5be3tkqNYezL/qXgJ82zpd9fhJn2AN7NpwRdIwpDfXuw6GknTP4HB17eirowUVjtBy39AustsNrbzo6sVP+gQ7PZlPv623JOlIfoVS9l067HzXvUO66LNduU772XK0SDeG+elMecPVxj5hflq84ajTVZXLuaNfmHZmF6uwvNqx3905JQrpYFF4oE+j+g2HChTTPcjpaqAr02/rrX2nSrX+oscvPipMB06XKqZHR3Xt6OsI4Bdr4+mhx0f1kiSX21saAQfAdeH8SyNmYfFqo9p694SnqzWsZ5CG9+x0RQHnZ/2t3yvghHSwOAWc0ZGheuSWno6vmwo4D8REaMQNwfrnPpsj4EyK7a6aOrsj4Lw75Wbd1jdUPWZ94Zg3MyFSkpSSefqyAadvWAfH1aYHb47QV4cLVPjvMHN+P9+VcJNVd7/xdZP7Pe/pMZH6r5/21uP/l+Ho5VL7/W7/ge3aasGXDVc8//yLgZr57yuRkhQfFeqoO3/u44d21Sv3D3LaV/qRM9qZXew01q5tG8fcf+y16egV/KJwLfEmYwAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDoEHAAAYDrXJOAsWrRIPXr0kI+Pj2JjY7Vt27Ym61esWKHIyEj5+PhowIABWrNmjWNbbW2tnn76aQ0YMEDt27dXeHi4Hn74YZ06dcrdpwEAAFoJtwecjz76SElJSZo3b5527typQYMGKSEhQfn5+S7rN2/erIkTJ2rq1KnatWuXxo0bp3HjxikzM1OSVFlZqZ07d+q5557Tzp079emnnyorK0t33323u08FAAC0Em4POPPnz9e0adM0ZcoU9evXT4sXL1a7du20ZMkSl/ULFy7UmDFjNHPmTEVFRemFF17Q0KFD9cYbb0iSAgIClJqaqvvvv199+/bV8OHD9cYbbygjI0PZ2dnuPh0AANAKuDXg1NTUKCMjQ/Hx8RcO6Omp+Ph4paenu5yTnp7uVC9JCQkJl6yXpJKSEnl4eCgwMNDl9urqapWWljrdAACAebk14BQWFqq+vl5hYWFO42FhYbLZbC7n2Gy2q6qvqqrS008/rYkTJ8rf399lTXJysgICAhy3iIiI73E2AACgtWjVn6Kqra3V/fffL8Mw9NZbb12ybvbs2SopKXHccnJyrmGXAADgWvNy586Dg4PVpk0b5eXlOY3n5eXJarW6nGO1Wq+o/ny4OXHihNauXXvJqzeSZLFYZLFYvudZAACA1satV3C8vb0VHR2ttLQ0x5jdbldaWpri4uJczomLi3Oql6TU1FSn+vPh5vDhw/ryyy/VqVMn95wAAABoldx6BUeSkpKSNHnyZMXExGjYsGFasGCBKioqNGXKFEnSww8/rC5duig5OVmSNGPGDI0aNUqvvPKKxo4dq+XLl2vHjh16++23JTWEm1/84hfauXOnVq9erfr6esf7c4KCguTt7e3uUwIAAD9ybg84DzzwgAoKCjR37lzZbDYNHjxYKSkpjjcSZ2dny9PzwoWkESNGaNmyZZozZ46eeeYZ9enTRytXrlT//v0lSbm5ufr8888lSYMHD3Y61rp16/TTn/7U3acEAAB+5NwecCQpMTFRiYmJLretX7++0diECRM0YcIEl/U9evSQYRjN2R4AADCZVv0pKgAAAFcIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHSuScBZtGiRevToIR8fH8XGxmrbtm1N1q9YsUKRkZHy8fHRgAEDtGbNGqfthmFo7ty56ty5s3x9fRUfH6/Dhw+78xQAAEAr4vaA89FHHykpKUnz5s3Tzp07NWjQICUkJCg/P99l/ebNmzVx4kRNnTpVu3bt0rhx4zRu3DhlZmY6al5++WW99tprWrx4sbZu3ar27dsrISFBVVVV7j4dAADQCrg94MyfP1/Tpk3TlClT1K9fPy1evFjt2rXTkiVLXNYvXLhQY8aM0cyZMxUVFaUXXnhBQ4cO1RtvvCGp4erNggULNGfOHN1zzz0aOHCg3n//fZ06dUorV6509+kAAIBWwMudO6+pqVFGRoZmz57tGPP09FR8fLzS09NdzklPT1dSUpLTWEJCgiO8HDt2TDabTfHx8Y7tAQEBio2NVXp6uh588MFG+6yurlZ1dbXj69LS0h9yWpeUcaJIq/ecbjR+prxGu08W6/bIULcc98fswOlS1dsN9e8S0Gz7LK+qc9z/Ys9pHSkod1n3/Kp9jcZ2nDjrcvxqNcc+ztuZXfyD9ldRXacNhwr0s/6d5eHRdO354xw8XabaersGdG14XFIybbrlhmB18Ln0jwRbyYUrpEu3Zmvj4YLv1e+Z8hrH/U8yTmpX9lnll1U3qluQesjl/JR9NpWeq73scT7ffcpxf9O3BSqudD3n+VX7tP/05X8mXLy/i+9/V73dcPr6r5uOqarWftn9N5ememvJfQHXmlsDTmFhoerr6xUWFuY0HhYWpoMHD7qcY7PZXNbbbDbH9vNjl6r5ruTkZD3//PPf6xyuRpatXO9+ffyS25vaZnbbj591y37Tj55R+tEzLre5Wu+aOnuzPA7N+VjW241m2d97my+/j+8eZ8eJC4/Lxxknr/hYXx7Iu+Lapmw4VKANh1wHpRWX6GfbsaIr2vdXhwsd93OKzl2y7krX/uL9bfq2sIlKZ1+4+KXnh+pg8VJ7i5fKq+sabbu4zx/qSvdl9feRXxPh+GIdfNrKw0MyjMvXXiw80Fff5l/4ZcbPp63T9t4h7XWkoEI3hPo51TXUNvTWwXKhxw4+XqqpuxA8z28b2i1QO7OL1TO4/YX5FudjuRLcwVtZeReON6BLgNZlFSjYz/uSc/wsV/4UfP6Xjy4dfa94znkBvhf67/Sdfrp2bNeo3hpgaTT23fWWJP+L9hvZuYOOFlY4be9wFefnDi179Gtk9uzZTleFSktLFRER0ezHuSncX9Nv691ofNG6I5KkzgE+um9ol2Y/7o/VqeIqfbYrV5I0dkBn9Qhu/A/ph+y7oKxagyKcrwzV1hvaeKhAt0eGOl3NKKuq0+6cYo3sE/y9j1lXb2h9VoFujwqV52WulFyJ8qo67cop1k9+QE/She8vSS6//+rt0vqsfI3qGyIvTw+dLq7Spxc9Ll/sPd3k/Isdya9Qnd1QX6vfD+r5xJlKlVfX6aZwf8eY3ZDOVtTIbhgK6dDwA/bix9NWWiVbSZWGdAuUJG0/dlY9g9urtKpWtfV2VdbUyxrgo9p6Q6XnatW/i7+KKmp1KK9Mw3sFSZIKyqoV0sGiTYcLdaaiRmNussrStuGV+g2HChTTPUhHCyvU2d9HN3XxV15plQ6eLpOlrad6BrfXybPnVFRRo4FdA3S2slYHT5eqX7i/2nl7qbq23vF4Hius0O6cEg2KCFDP4PYyDGntwXz9pE+w9uaWqGvHdjpwulTDegap3m7om5xijbwhWOuyCjSidycdtJXqeGGlbr0xRPV2uzoH+CrM30dZtlK1beOpuweHq7rOrvVZ+fL3aSuvNp46ZCtTJz9vx/d9YVmNDDWspZ+lrSxenjqUV6aO7b3lZ/GSn8VLheXV+mnfEK07WKDNRwp1Q6ifrP4+Cg/0Vc7ZSsfjcrr4nLLyyjWgi78sXm1k8fJUWVWdThRVKNLqr2k/6SVf7zZ66j9uVOqBPN0fE6Edx4tUUF6tsxW1mjgsQsWVtfLz8dJtkSH6YGqsPtl5UraSKsV076jOgb4qqqjRLTcEa+OhAoV2sGj1ntMK9bfIy9ND/Tr7657BXbQiI0ff5pfrxrAOGjugs9P31OJfRusfmTb9fFC4vs0v17HCcnl6eMjP0hA2JCm2Vye9MK6/fLw81Se04Xv4T+MHqM5uaGi3jpKk+fcP1ue7T2lMf6tj38N7BemFe25SUUWtOvl5q6K6Tm08PbTp20L5Wbx0z+AuuiHUT5/tylWXQB/16+yvF8b116c7c5u8ct8rxE9//sVAvbPpmO4b2kWGIfW1dtCp4iq9n35c//mTXgr0batjhRW6d0jDc8evftpbQe29Fd294xX/e/tFdFfV1tvVJ7SDbr0xRC+M66+9J4vVvVN7PXjzhefCZf8Zq29OFmvizd0a7WPuXf30+Te56tapvYLat1XGibO6PfLChYbn7uqnKKu/QjpYlFt8ThYvTz3gYj/XkodhXG2OvnI1NTVq166dPv74Y40bN84xPnnyZBUXF+vvf/97ozndunVTUlKSnnjiCcfYvHnztHLlSu3evVtHjx5V7969tWvXLg0ePNhRM2rUKA0ePFgLFy68bF+lpaUKCAhQSUmJ/P39L1v/Q/WY9YUk6eeDwvX6xCFuP96PxdajZ/TA21skSUseiXH6x4Dmc/77q2tHX216+vbL1m8/XqQJixteIn5ncoxe/fKQMnMbXqI5/tJY9zUKAD/Q1Tx/u/VNxt7e3oqOjlZaWppjzG63Ky0tTXFxcS7nxMXFOdVLUmpqqqO+Z8+eslqtTjWlpaXaunXrJfcJAACuL25/iSopKUmTJ09WTEyMhg0bpgULFqiiokJTpkyRJD388MPq0qWLkpOTJUkzZszQqFGj9Morr2js2LFavny5duzYobfffluS5OHhoSeeeEJ/+MMf1KdPH/Xs2VPPPfecwsPDna4SAQCA65fbA84DDzyggoICzZ07VzabTYMHD1ZKSorjTcLZ2dny9LxwIWnEiBFatmyZ5syZo2eeeUZ9+vTRypUr1b9/f0fNb3/7W1VUVOixxx5TcXGxRo4cqZSUFPn4+Lj7dAAAQCtwTd5knJiYqMTERJfb1q9f32hswoQJmjBhwiX35+Hhod///vf6/e9/31wtAgAAE+FvUQEAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANMh4AAAANNxa8ApKirSpEmT5O/vr8DAQE2dOlXl5eVNzqmqqtL06dPVqVMn+fn5afz48crLy3Ns3717tyZOnKiIiAj5+voqKipKCxcudOdpAACAVsatAWfSpEnat2+fUlNTtXr1am3cuFGPPfZYk3OefPJJrVq1SitWrNCGDRt06tQp3XfffY7tGRkZCg0N1QcffKB9+/bp2Wef1ezZs/XGG2+481QAAEAr4uWuHR84cEApKSnavn27YmJiJEmvv/667rzzTv3lL39ReHh4ozklJSV65513tGzZMt1+++2SpHfffVdRUVHasmWLhg8frkcffdRpTq9evZSenq5PP/1UiYmJ7jodAADQirjtCk56eroCAwMd4UaS4uPj5enpqa1bt7qck5GRodraWsXHxzvGIiMj1a1bN6Wnp1/yWCUlJQoKCrrk9urqapWWljrdAACAebkt4NhsNoWGhjqNeXl5KSgoSDab7ZJzvL29FRgY6DQeFhZ2yTmbN2/WRx991ORLX8nJyQoICHDcIiIiru5kAABAq3LVAWfWrFny8PBo8nbw4EF39NpIZmam7rnnHs2bN0933HHHJetmz56tkpISxy0nJ+ea9AcAAFrGVb8H56mnntIjjzzSZE2vXr1ktVqVn5/vNF5XV6eioiJZrVaX86xWq2pqalRcXOx0FScvL6/RnP3792v06NF67LHHNGfOnCb7sVgsslgsTdYAAADzuOqAExISopCQkMvWxcXFqbi4WBkZGYqOjpYkrV27Vna7XbGxsS7nREdHq23btkpLS9P48eMlSVlZWcrOzlZcXJyjbt++fbr99ts1efJkvfjii1d7CgAAwOTc9h6cqKgojRkzRtOmTdO2bdv09ddfKzExUQ8++KDjE1S5ubmKjIzUtm3bJEkBAQGaOnWqkpKStG7dOmVkZGjKlCmKi4vT8OHDJTW8LHXbbbfpjjvuUFJSkmw2m2w2mwoKCtx1KgAAoJVx28fEJWnp0qVKTEzU6NGj5enpqfHjx+u1115zbK+trVVWVpYqKysdY6+++qqjtrq6WgkJCXrzzTcd2z/++GMVFBTogw8+0AcffOAY7969u44fP+7O0wEAAK2EWwNOUFCQli1bdsntPXr0kGEYTmM+Pj5atGiRFi1a5HLO7373O/3ud79rzjYBAIDJ8LeoAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwAACA6RBwgFbO38dLktSvs/8V1ftZvFzeBwAz4acb0Mot/c/hWp+Vr/HRXa+oPtLaQS+PH6iaertu7hHk5u4AoGUQcIBWbkDXAA3oGnDF9R4eHrr/5gg3dgQALY+XqAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOkQcAAAgOm4NeAUFRVp0qRJ8vf3V2BgoKZOnary8vIm51RVVWn69Onq1KmT/Pz8NH78eOXl5bmsPXPmjLp27SoPDw8VFxe74QwAAEBr5NaAM2nSJO3bt0+pqalavXq1Nm7cqMcee6zJOU8++aRWrVqlFStWaMOGDTp16pTuu+8+l7VTp07VwIED3dE6AABoxdwWcA4cOKCUlBT99a9/VWxsrEaOHKnXX39dy5cv16lTp1zOKSkp0TvvvKP58+fr9ttvV3R0tN59911t3rxZW7Zscap96623VFxcrP/+7/921ykAAIBWym0BJz09XYGBgYqJiXGMxcfHy9PTU1u3bnU5JyMjQ7W1tYqPj3eMRUZGqlu3bkpPT3eM7d+/X7///e/1/vvvy9Pz8qdQXV2t0tJSpxsAADAvtwUcm82m0NBQpzEvLy8FBQXJZrNdco63t7cCAwOdxsPCwhxzqqurNXHiRP35z39Wt27drqiX5ORkBQQEOG4RERFXf0IAAKDVuOqAM2vWLHl4eDR5O3jwoDt6lSTNnj1bUVFR+uUvf3lVc0pKShy3nJwct/UHAABantfVTnjqqaf0yCOPNFnTq1cvWa1W5efnO43X1dWpqKhIVqvV5Tyr1aqamhoVFxc7XcXJy8tzzFm7dq327t2rjz/+WJJkGIYkKTg4WM8++6yef/75Rvu1WCyyWCxXeooAAKCVu+qAExISopCQkMvWxcXFqbi4WBkZGYqOjpbUEE7sdrtiY2NdzomOjlbbtm2Vlpam8ePHS5KysrKUnZ2tuLg4SdInn3yic+fOOeZs375djz76qL766iv17t37ak8HAACY0FUHnCsVFRWlMWPGaNq0aVq8eLFqa2uVmJioBx98UOHh4ZKk3NxcjR49Wu+//76GDRumgIAATZ06VUlJSQoKCpK/v79+/etfKy4uTsOHD5ekRiGmsLDQcbzvvncHAABcn9wWcCRp6dKlSkxM1OjRo+Xp6anx48frtddec2yvra1VVlaWKisrHWOvvvqqo7a6uloJCQl688033dkmAAAwGbcGnKCgIC1btuyS23v06OF4D815Pj4+WrRokRYtWnRFx/jpT3/aaB8AAOD6xt+iAgAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApkPAAQAApuO2gFNUVKRJkybJ399fgYGBmjp1qsrLy5ucU1VVpenTp6tTp07y8/PT+PHjlZeX16juvffe08CBA+Xj46PQ0FBNnz7dXacBAABaIbcFnEmTJmnfvn1KTU3V6tWrtXHjRj322GNNznnyySe1atUqrVixQhs2bNCpU6d03333OdXMnz9fzz77rGbNmqV9+/bpyy+/VEJCgrtOAwAAtEJe7tjpgQMHlJKSou3btysmJkaS9Prrr+vOO+/UX/7yF4WHhzeaU1JSonfeeUfLli3T7bffLkl69913FRUVpS1btmj48OE6e/as5syZo1WrVmn06NGOuQMHDnTHaQAAgFbKLVdw0tPTFRgY6Ag3khQfHy9PT09t3brV5ZyMjAzV1tYqPj7eMRYZGalu3bopPT1dkpSamiq73a7c3FxFRUWpa9euuv/++5WTk9NkP9XV1SotLXW6AQAA83JLwLHZbAoNDXUa8/LyUlBQkGw22yXneHt7KzAw0Gk8LCzMMefo0aOy2+364x//qAULFujjjz9WUVGR/uM//kM1NTWX7Cc5OVkBAQGOW0RExA87QVwRP58LFwj9LG1bsBMAwPXmqgLOrFmz5OHh0eTt4MGD7upVdrtdtbW1eu2115SQkKDhw4frww8/1OHDh7Vu3bpLzps9e7ZKSkoct8td8UHz6NfZX38aP0B/GNdfMd07tnQ7AIDryFW9B+epp57SI4880mRNr169ZLValZ+f7zReV1enoqIiWa1Wl/OsVqtqampUXFzsdBUnLy/PMadz586SpH79+jm2h4SEKDg4WNnZ2ZfsyWKxyGKxNNk3mp+Hh4ceuLlbS7cBALgOXVXACQkJUUhIyGXr4uLiVFxcrIyMDEVHR0uS1q5dK7vdrtjYWJdzoqOj1bZtW6WlpWn8+PGSpKysLGVnZysuLk6SdMsttzjGu3btKqnh4+iFhYXq3r371ZwKAAAwMbe8BycqKkpjxozRtGnTtG3bNn399ddKTEzUgw8+6PgEVW5uriIjI7Vt2zZJUkBAgKZOnaqkpCStW7dOGRkZmjJliuLi4jR8+HBJ0o033qh77rlHM2bM0ObNm5WZmanJkycrMjJSt912mztOBQAAtEJu+39wli5dqsjISI0ePVp33nmnRo4cqbffftuxvba2VllZWaqsrHSMvfrqq7rrrrs0fvx43XrrrbJarfr000+d9vv+++8rNjZWY8eO1ahRo9S2bVulpKSobVvexAoAABp4GIZhtHQT11ppaakCAgJUUlIif39/tx+vx6wvJEk/HxSu1ycOcfvxgKtx1+tfKTO34b9OOP7S2BbuBgAu7Wqev/lbVAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIONdQeIBPS7cANHJDiJ8kyduLHwcAzMOrpRu4Hnw4bbh2Zp/VxGHdWroVoJHZd0bphlA/3XJDcEu3AgDNxsMwDKOlm7jWSktLFRAQoJKSEvn7+7d0OwAA4ApczfM316QBAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpEHAAAIDpeLV0Ay3h/B9QLy0tbeFOAADAlTr/vH3+ebwp12XAKSsrkyRFRES0cCcAAOBqlZWVKSAgoMkaD+NKYpDJ2O12nTp1Sh06dJCHh0ez7be0tFQRERHKycmRv79/s+0Xzljna4e1vjZY52uDdb523LXWhmGorKxM4eHh8vRs+l021+UVHE9PT3Xt2tVt+/f39+cfzzXAOl87rPW1wTpfG6zzteOOtb7clZvzeJMxAAAwHQIOAAAwHQJOM7JYLJo3b54sFktLt2JqrPO1w1pfG6zztcE6Xzs/hrW+Lt9kDAAAzI0rOAAAwHQIOAAAwHQIOAAAwHQIOAAAwHQIOM1o0aJF6tGjh3x8fBQbG6tt27a1dEutRnJysm6++WZ16NBBoaGhGjdunLKyspxqqqqqNH36dHXq1El+fn4aP3688vLynGqys7M1duxYtWvXTqGhoZo5c6bq6uqu5am0Ki+99JI8PDz0xBNPOMZY5+aTm5urX/7yl+rUqZN8fX01YMAA7dixw7HdMAzNnTtXnTt3lq+vr+Lj43X48GGnfRQVFWnSpEny9/dXYGCgpk6dqvLy8mt9Kj9a9fX1eu6559SzZ0/5+vqqd+/eeuGFF5z+VhHr/P1s3LhRP//5zxUeHi4PDw+tXLnSaXtzreuePXv0k5/8RD4+PoqIiNDLL7/cPCdgoFksX77c8Pb2NpYsWWLs27fPmDZtmhEYGGjk5eW1dGutQkJCgvHuu+8amZmZxjfffGPceeedRrdu3Yzy8nJHzeOPP25EREQYaWlpxo4dO4zhw4cbI0aMcGyvq6sz+vfvb8THxxu7du0y1qxZYwQHBxuzZ89uiVP60du2bZvRo0cPY+DAgcaMGTMc46xz8ygqKjK6d+9uPPLII8bWrVuNo0ePGv/85z+Nb7/91lHz0ksvGQEBAcbKlSuN3bt3G3fffbfRs2dP49y5c46aMWPGGIMGDTK2bNlifPXVV8YNN9xgTJw4sSVO6UfpxRdfNDp16mSsXr3aOHbsmLFixQrDz8/PWLhwoaOGdf5+1qxZYzz77LPGp59+akgyPvvsM6ftzbGuJSUlRlhYmDFp0iQjMzPT+PDDDw1fX1/jf/7nf35w/wScZjJs2DBj+vTpjq/r6+uN8PBwIzk5uQW7ar3y8/MNScaGDRsMwzCM4uJio23btsaKFSscNQcOHDAkGenp6YZhNPxj9PT0NGw2m6PmrbfeMvz9/Y3q6uprewI/cmVlZUafPn2M1NRUY9SoUY6Awzo3n6efftoYOXLkJbfb7XbDarUaf/7znx1jxcXFhsViMT788EPDMAxj//79hiRj+/btjpp//OMfhoeHh5Gbm+u+5luRsWPHGo8++qjT2H333WdMmjTJMAzWubl8N+A017q++eabRseOHZ1+djz99NNG3759f3DPvETVDGpqapSRkaH4+HjHmKenp+Lj45Went6CnbVeJSUlkqSgoCBJUkZGhmpra53WODIyUt26dXOscXp6ugYMGKCwsDBHTUJCgkpLS7Vv375r2P2P3/Tp0zV27Fin9ZRY5+b0+eefKyYmRhMmTFBoaKiGDBmi//3f/3VsP3bsmGw2m9NaBwQEKDY21mmtAwMDFRMT46iJj4+Xp6entm7deu1O5kdsxIgRSktL06FDhyRJu3fv1qZNm/Szn/1MEuvsLs21runp6br11lvl7e3tqElISFBWVpbOnj37g3q8Lv/YZnMrLCxUfX290w98SQoLC9PBgwdbqKvWy26364knntAtt9yi/v37S5JsNpu8vb0VGBjoVBsWFiabzeaocfUYnN+GBsuXL9fOnTu1ffv2RttY5+Zz9OhRvfXWW0pKStIzzzyj7du36ze/+Y28vb01efJkx1q5WsuL1zo0NNRpu5eXl4KCgljrf5s1a5ZKS0sVGRmpNm3aqL6+Xi+++KImTZokSayzmzTXutpsNvXs2bPRPs5v69ix4/fukYCDH53p06crMzNTmzZtaulWTCcnJ0czZsxQamqqfHx8WrodU7Pb7YqJidEf//hHSdKQIUOUmZmpxYsXa/LkyS3cnXn87W9/09KlS7Vs2TLddNNN+uabb/TEE08oPDycdb7O8RJVMwgODlabNm0afdIkLy9PVqu1hbpqnRITE7V69WqtW7dOXbt2dYxbrVbV1NSouLjYqf7iNbZarS4fg/Pb0PASVH5+voYOHSovLy95eXlpw4YNeu211+Tl5aWwsDDWuZl07txZ/fr1cxqLiopSdna2pAtr1dTPDavVqvz8fKftdXV1KioqYq3/bebMmZo1a5YefPBBDRgwQA899JCefPJJJScnS2Kd3aW51tWdP08IOM3A29tb0dHRSktLc4zZ7XalpaUpLi6uBTtrPQzDUGJioj777DOtXbu20SXL6OhotW3b1mmNs7KylJ2d7VjjuLg47d271+kfVGpqqvz9/Rs90VyvRo8erb179+qbb75x3GJiYjRp0iTHfda5edxyyy2N/quDQ4cOqXv37pKknj17ymq1Oq11aWmptm7d6rTWxcXFysjIcNSsXbtWdrtdsbGx1+AsfvwqKyvl6en8VNamTRvZ7XZJrLO7NNe6xsXFaePGjaqtrXXUpKamqm/fvj/o5SlJfEy8uSxfvtywWCzGe++9Z+zfv9947LHHjMDAQKdPmuDS/uu//ssICAgw1q9fb5w+fdpxq6ysdNQ8/vjjRrdu3Yy1a9caO3bsMOLi4oy4uDjH9vMfX77jjjuMb775xkhJSTFCQkL4+PJlXPwpKsNgnZvLtm3bDC8vL+PFF180Dh8+bCxdutRo166d8cEHHzhqXnrpJSMwMND4+9//buzZs8e45557XH7MdsiQIcbWrVuNTZs2GX369LnuP758scmTJxtdunRxfEz8008/NYKDg43f/va3jhrW+fspKyszdu3aZezatcuQZMyfP9/YtWuXceLECcMwmmddi4uLjbCwMOOhhx4yMjMzjeXLlxvt2rXjY+I/Nq+//rrRrVs3w9vb2xg2bJixZcuWlm6p1ZDk8vbuu+86as6dO2f86le/Mjp27Gi0a9fOuPfee43Tp0877ef48ePGz372M8PX19cIDg42nnrqKaO2tvYan03r8t2Awzo3n1WrVhn9+/c3LBaLERkZabz99ttO2+12u/Hcc88ZYWFhhsViMUaPHm1kZWU51Zw5c8aYOHGi4efnZ/j7+xtTpkwxysrKruVp/KiVlpYaM2bMMLp162b4+PgYvXr1Mp599lmnjx2zzt/PunXrXP5cnjx5smEYzbeuu3fvNkaOHGlYLBajS5cuxksvvdQs/XsYxkX/3SMAAIAJ8B4cAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOgQcAABgOv8/JMaMxoEVMkQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Convert lists to numpy arrays for easier manipulation\n", + "loss_baseline_np = np.array(loss_baseline)\n", + "loss_jit_np = np.array(loss_jit)\n", + "loss_tcompile_np = np.array(loss_tcompile)\n", + "\n", + "# Calculate deltas\n", + "delta_jit_baseline = (loss_jit_np - loss_baseline_np)\n", + "delta_tcompile_baseline = (loss_tcompile_np - loss_baseline_np)\n", + "\n", + "# Plot deltas\n", + "plt.plot(it_jit, delta_jit_baseline, label=\"JIT - Baseline\", linestyle='-', color='blue', alpha=0.6)\n", + "plt.plot(it_tcompile, delta_tcompile_baseline, label=\"TCompile - Baseline\", linestyle='--', color='red', alpha=0.6)\n", + "\n", + "plt.xlabel('Iteration step')\n", + "plt.ylabel('Delta Loss')\n", + "plt.title('Delta Loss Curve (compared to Baseline)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] } ], "metadata": { From b86268c919bf3b5e0c62144117fa72691d246f03 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 07:55:27 +0000 Subject: [PATCH 30/57] torch compile perf logs --- .../logs/torch-compile-perf_baseline.log | 1010 +++++++++++++++++ .../logs/torch-compile-perf_jit.log | 1010 +++++++++++++++++ .../logs/torch-compile-perf_torch-compile.log | 1010 +++++++++++++++++ 3 files changed, 3030 insertions(+) create mode 100644 notebook/trainer-validation/logs/torch-compile-perf_baseline.log create mode 100644 notebook/trainer-validation/logs/torch-compile-perf_jit.log create mode 100644 notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log diff --git a/notebook/trainer-validation/logs/torch-compile-perf_baseline.log b/notebook/trainer-validation/logs/torch-compile-perf_baseline.log new file mode 100644 index 00000000..64bde882 --- /dev/null +++ b/notebook/trainer-validation/logs/torch-compile-perf_baseline.log @@ -0,0 +1,1010 @@ +[2023-07-08 05:13:47,599] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) +[RWKV.model] Running RWKV model with : torch-native +ninja: no work to do. +[2023-07-08 05:14:01,190] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented +[2023-07-08 05:14:01,191] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. +[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096) +ninja: no work to do. +Time to load cpu_adam op: 2.3342676162719727 seconds +Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] + Training: 0it [00:00, ?it/s] Training: 0%| | 0/1315 [00:00 Date: Sat, 8 Jul 2023 07:55:34 +0000 Subject: [PATCH 31/57] bptt validation --- .../trainer-validation/bptt-validation.ipynb | 785 ++++++++++++++++++ 1 file changed, 785 insertions(+) create mode 100644 notebook/trainer-validation/bptt-validation.ipynb diff --git a/notebook/trainer-validation/bptt-validation.ipynb b/notebook/trainer-validation/bptt-validation.ipynb new file mode 100644 index 00000000..63ea4e73 --- /dev/null +++ b/notebook/trainer-validation/bptt-validation.ipynb @@ -0,0 +1,785 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# InfCtx trainer validation\n", + "This model being trained has the same settings as raven 1B5 model.\n", + "- Layer count: 24\n", + "- Embed size: 2048\n", + "\n", + "The goal is to validate loss rate change, across the exact same hyper parameters with the following\n", + "- 1024 data chunk size\n", + "- same learningrate / weightdecay / seed\n", + "- \"teven/enwiki_10k\" dataset, chunked to 1024 token sizes\n", + "\n", + "With only the change in training context size\n", + "- 1024 context vs 128 context\n", + "\n", + "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps\n", + ">\n", + "> And that you have completed the `baseline-setup.ipynb`" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configure and apply your preferred settings\n", + "\n", + "Adjust your desired deepspeed settings, and gpu device count.\n", + "\n", + "Enable/Disable WANDB here as well ( Enabled by default, as we need the loss curve for this experiment )\n", + "\n", + "( note you will need to rerun this cell, if you restart your env )" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DEEPSPEED_STRAT: deepspeed_stage_2_offload\n", + "ENABLE_WANDB: True\n", + "GPU_DEVICES: auto\n" + ] + } + ], + "source": [ + "DEEPSPEED_STRAT=\"deepspeed_stage_2_offload\"\n", + "GPU_DEVICES=\"auto\"\n", + "ENABLE_WANDB=True\n", + "WANDB_PREFIX=\"infctx-bptt-validation\"\n", + "\n", + "print(\"DEEPSPEED_STRAT:\", DEEPSPEED_STRAT)\n", + "print(\"ENABLE_WANDB:\", ENABLE_WANDB)\n", + "print(\"GPU_DEVICES:\", GPU_DEVICES)\n", + "\n", + "if ENABLE_WANDB:\n", + " WANDB_MODE=\"online\"\n", + "else:\n", + " WANDB_MODE=\"disabled\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# (optional) Baseline full context (1024) training\n", + "\n", + "(you can skip this, and use the optional baseline found in `baseline-setup.ipynb`)\n", + "\n", + "Perform a full 1 epoch training run of training context size = 1024. Ensuring all data samples fit within the allocated training size." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-07-01 20:53:18,310] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "Global seed set to 3941088705\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mpicocreator\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.4\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230701_205320-k8flu72z\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-validation-full (train-ctx=1024, data-ctx=1024, bs=12)\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/k8flu72z\u001b[0m\n", + "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/wkv_1024_bf16/build.ninja...\n", + "Building extension module wkv_1024_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module wkv_1024_bf16...\n", + "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 675.41it/s]\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", + "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", + "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "[rank: 0] Global seed set to 3941088705\n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[2023-07-01 20:53:34,204] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "Enabling DeepSpeed BF16.\n", + "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/pytorch/callbacks/model_checkpoint.py:615: UserWarning: Checkpoint directory /home/picocreator/rwkv-proj/infctx-dev/checkpoint/trainer-validaiton/infctx-validation-full exists and is not empty.\n", + " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\u001b[93m [WARNING] \u001b[0m cpu_adam cuda is missing or is incompatible with installed torch, only cpu ops can be compiled!\n", + "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", + "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module cpu_adam...\n", + "Time to load cpu_adam op: 2.312431812286377 seconds\n", + "Loading `train_dataloader` to estimate number of stepping batches.\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "Epoch 0: 100%|█| 5318/5318 [51:02<00:00, 1.74it/s, v_num=u72z, train/loss=5.940\n", + "Validation: 0it [00:00, ?it/s]\u001b[A\n", + "Validation: 0%| | 0/54 [00:00 Date: Sat, 8 Jul 2023 07:55:57 +0000 Subject: [PATCH 32/57] WIP torch compile optimization --- RWKV-v4neo/src/model.py | 104 ++++++++++++++++++++++++++++++++-------- 1 file changed, 84 insertions(+), 20 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index fe4256ed..7fcc311f 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -44,22 +44,69 @@ def is_torch_version_above(required_version): RWKV_TORCH_COMPILE = os.getenv("RWKV_TORCH_COMPILE", f"{IS_TORCH_2_1}").lower() in ("1", "true", "yes") RWKV_TORCH_RUN_MODE = None -# We enable JITModule/Function or torch compile function +# We enable JITMod*/Function when supporting torch.jit +# We use TorchCompile* when supporting torch compile # based on the current runtime settings if RWKV_TORCH_COMPILE: RWKV_TORCH_RUN_MODE = "torch-compile" - JITModule = nn.Module - JITFunction = lambda x: x + + JITModClass = nn.Module + JITModMethod = lambda x: x + JITFunction = lambda x: x + + # PS: i have tried mode="max-autotune", and mode="reduce-overhead", however they crash + # for now. We may introduce them in the future once they are stable + + # TCompileMax, is reserved only for functions we know that can be perfectly compiled + # without any graph breaks - providing the highest level of optimization via torch.compile + TCompileMax = lambda x: torch.compile(x, fullgraph=True) + + # Baseline, and eager mode are for torch comile operations, that can be partially optimized + TCompileBaseline = lambda x: torch.compile(x, fullgraph=False) + TCompileEager = lambda x: torch.compile(x, fullgraph=False, backend="eager") + + # Used to wrap functions which are **not** torch.compile compatible + TCompileDisable = torch._dynamo.disable + + # The following are known warnings in the nightly build, that can be safely ignored for stable release + # + # `torch._inductor.utils: [WARNING] DeviceCopy in input program` + # https://discuss.pytorch.org/t/what-can-cause-warning-devicecopy-in-input-program/175566 + elif RWKV_JIT_ON: RWKV_TORCH_RUN_MODE = "torch-jit" - JITModule = torch.jit.ScriptModule - JITFunction = torch.jit.script_method + JITModClass = torch.jit.ScriptModule + JITModMethod = torch.jit.script_method + JITFunction = torch.jit.script + + TCompileMax = lambda x: x + TCompileBaseline = lambda x: x + TCompileEager = lambda x: x + TCompileDisable = lambda x: x else: RWKV_TORCH_RUN_MODE = "torch-native" - JITModule = nn.Module - JITFunction = lambda x: x + JITModClass = nn.Module + JITModMethod = lambda x: x + JITFunction = lambda x: x + + TCompileMax = lambda x: x + TCompileBaseline = lambda x: x + TCompileEager = lambda x: x + TCompileDisable = lambda x: x -print(f"[RWKV.model] Running RWKV model with : {RWKV_TORCH_RUN_MODE}") +print(f"[RWKV.model] Running RWKV model via the following optimization mode : {RWKV_TORCH_RUN_MODE}") + +# --- +# Isolating out known operations that **does not work** with torch.compile +# --- + +@TCompileDisable +def deepspeed_checkpoint(*args, **kwargs): + return deepspeed.checkpointing.checkpoint(*args, **kwargs) + +@TCompileDisable +def wkv_op(time_decay, time_first, k, v, wkv_state): + return torch.ops.rwkv.wkv(time_decay, time_first, k, v, wkv_state) ######################################################################################################## # RWKV: State Blocks @@ -122,7 +169,7 @@ def __setitem__(self, layer: int, state: BlockState): # RWKV: RWKV Time-mix + RWKV Channel-mix ######################################################################################################## -class RWKV_TimeMix(JITModule): +class RWKV_TimeMix(JITModClass): def __init__(self, layer_id, n_layer, n_embd, dim_att): super().__init__() @@ -161,8 +208,9 @@ def __init__(self, layer_id, n_layer, n_embd, dim_att): self.receptance = nn.Linear(n_embd, dim_att, bias=False) self.output = nn.Linear(dim_att, n_embd, bias=False) - @JITFunction - def forward(self, x, last_state: TimeMixState): + @JITModMethod + @TCompileMax + def _forward_kvsr(self, x, last_state: TimeMixState): # Mix x with the previous timestep to produce xk, xv, xr xx = torch.concat((last_state.shift_state.unsqueeze(1), x[:, :-1]), dim=1) @@ -176,15 +224,26 @@ def forward(self, x, last_state: TimeMixState): sr = torch.sigmoid(r) - y, new_wkv_state = torch.ops.rwkv.wkv(self.time_decay, self.time_first, - k, v, last_state.wkv_state) - return self.output(sr * y), TimeMixState(x[:, -1], new_wkv_state) + return k, v, sr + + @JITModMethod + @TCompileMax + def _forward_out(self, sr, y, x_l, new_wkv_state): + return self.output(sr * y), TimeMixState(x_l, new_wkv_state) + + @JITModMethod + @TCompileBaseline + def forward(self, x, last_state: TimeMixState): + k, v, sr = self._forward_kvsr(x, last_state) + y, new_wkv_state = wkv_op(self.time_decay, self.time_first, + k, v, last_state.wkv_state) + return self._forward_out(sr, y, x[:, -1], new_wkv_state) ######################################################################################################## -class RWKV_ChannelMix(JITModule): +class RWKV_ChannelMix(JITModClass): def __init__(self, layer_id, n_layer, n_embd, dim_ffn): super().__init__() @@ -201,7 +260,8 @@ def __init__(self, layer_id, n_layer, n_embd, dim_ffn): self.receptance = nn.Linear(n_embd, n_embd, bias=False) self.value = nn.Linear(dim_ffn, n_embd, bias=False) - @JITFunction + @JITModMethod + @TCompileMax def forward(self, x, last_state: ChannelMixState): xx = torch.concat((last_state.shift_state.unsqueeze(1), x[:, :-1]), dim=1) @@ -357,7 +417,7 @@ def __init__(self, def configure_optimizers(self): if self.bptt_learning == False: if self.deepspeed_stage >= 2 or self.deepspeed_offload: - print("[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length ({self.ctx_len})") + print(f"[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length ({self.ctx_len})") else: if self.trainer.num_devices > 1: if self.bptt_learning_range <= 0: @@ -548,6 +608,7 @@ def deepspeed_stage(self) -> int: return "stage" in cfg return -1 + @TCompileBaseline def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, last_wkv_states: torch.Tensor): B, T = idx.size() @@ -561,7 +622,7 @@ def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, zip(self.blocks, BlockStateList(last_shift_states, last_wkv_states))): if self.grad_cp: - x, new_state = deepspeed.checkpointing.checkpoint( + x, new_state = deepspeed_checkpoint( block, x, last_state) else: x, new_state = block(x, last_state) @@ -817,7 +878,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, segment_size = self.ctx_len for i in range(segment_count): if i < segment_count-1: - total_loss, new_shift_states, new_wkv_states, steps = deepspeed.checkpointing.checkpoint( + total_loss, new_shift_states, new_wkv_states, steps = deepspeed_checkpoint( checkpointed_step, idx[:, i * segment_size:(i + 1) * segment_size], targets[:, i * segment_size:(i + 1) * segment_size], @@ -858,10 +919,12 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, return total_loss + @TCompileBaseline def training_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, True) + self.log('train/loss', total_loss, prog_bar=True) - # If set - forces the train/loss log line to always be on a new line + # If set - forces the above train/loss log line to always be on a new line if self.substep_logging: print("") @@ -871,6 +934,7 @@ def training_step(self, batch, batch_idx): return total_loss + @TCompileBaseline def validation_step(self, batch, batch_idx): total_loss = self.compute_loss(batch, batch_idx, False) self.log('validation/loss', total_loss, prog_bar=True, sync_dist=True) From add115a457817c3caee7e9cd9010c7bac27025d3 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 07:56:04 +0000 Subject: [PATCH 33/57] setup update --- README.md | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index a3a04abd..ffb07044 100644 --- a/README.md +++ b/README.md @@ -31,20 +31,27 @@ The following features are not yet supported (that may exist in [blinks original ## Environment setup The following venv setup using conda, modify for your use case respectively -``` +```bash # ninja-build is required for the new trainer sudo apt-get install ninja-build +# Update conda & its package listings +conda update conda + # Virtual env, with python 3.11 conda create -n rwkv-infctx python=3.11 pip conda activate rwkv-infctx -# Install pytorch -conda install -y pytorch torchvision torchaudio pytorch-cuda=11.7 -c pytorch -c nvidia +# Install pytorch (>=2.0.1) +# conda install -y pytorch==2.0.1 torchvision==0.15.1 torchaudio==2.0.1 pytorch-cuda=11.8 -c pytorch -c nvidia + +# Currently for torch.compile + 3.11 to work, we need the nightly 2.0.1 +# we expect this fix to be out in 2.0.2, and if so, use the previous line instead +conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch-nightly -c nvidia # We use python -m pip, instead of pip directly, as it resolve issues with venv not loading the right pip python -m pip install datasets transformers -python -m pip install lightning==2.0.2 deepspeed==0.9.3 +python -m pip install lightning==2.0.4 deepspeed==0.9.5 python -m pip install ninja numexpr jsonargparse 'jsonargparse[signatures]' python -m pip install lm-dataformat ftfy sentencepiece tokenizers wandb ``` From 00b54f569325a2c973b5ff66984f94f83101aaff Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 08:03:59 +0000 Subject: [PATCH 34/57] bptt_validation notebook (cleanup of various config files) --- notebook/trainer-validation/bptt-validation.ipynb | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/notebook/trainer-validation/bptt-validation.ipynb b/notebook/trainer-validation/bptt-validation.ipynb index 63ea4e73..c879c7d9 100644 --- a/notebook/trainer-validation/bptt-validation.ipynb +++ b/notebook/trainer-validation/bptt-validation.ipynb @@ -238,8 +238,7 @@ " -c ../notebook/trainer-validation/config/baseline-1024.yaml \\\n", " --trainer.logger.init_args.name=\"{WANDB_PREFIX} (full, train-ctx=1024, data-ctx=1024)\" \\\n", " --trainer.strategy=\"{DEEPSPEED_STRAT}\" \\\n", - " --trainer.devices=\"{GPU_DEVICES}\" \\\n", - " --callbacks[0].init_args.dirpath=\"../checkpoint/trainer-validaiton/{WANDB_PREFIX}-baseline-1024\"" + " --trainer.devices=\"{GPU_DEVICES}\"" ] }, { @@ -410,8 +409,7 @@ " --trainer.strategy=\"{DEEPSPEED_STRAT}\" \\\n", " --trainer.devices=\"{GPU_DEVICES}\" \\\n", " --model.bptt_learning=\"true\" \\\n", - " --model.ctx_len=512 \\\n", - " --callbacks[0].init_args.dirpath=\"../checkpoint/trainer-validaiton/{WANDB_PREFIX}-bptt-512\"" + " --model.ctx_len=512" ] }, { @@ -582,8 +580,7 @@ " --trainer.strategy=\"{DEEPSPEED_STRAT}\" \\\n", " --trainer.devices=\"{GPU_DEVICES}\" \\\n", " --model.bptt_learning=\"true\" \\\n", - " --model.ctx_len=128 \\\n", - " --callbacks[0].init_args.dirpath=\"../checkpoint/trainer-validaiton/{WANDB_PREFIX}-bptt-512\"" + " --model.ctx_len=128" ] }, { @@ -755,8 +752,7 @@ " --trainer.devices=\"{GPU_DEVICES}\" \\\n", " --model.bptt_learning=\"true\" \\\n", " --model.bptt_learning_range=1 \\\n", - " --model.ctx_len=128 \\\n", - " --callbacks[0].init_args.dirpath=\"../checkpoint/trainer-validaiton/{WANDB_PREFIX}-last-128\"" + " --model.ctx_len=128" ] } ], From 0e251ae370fca0af3e4bfa3a1bd2379d3f46169b Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 08:08:23 +0000 Subject: [PATCH 35/57] dropped infctx-validation notebook (in favour of bptt), added gitignore for toch compile logs --- .gitignore | 4 + .../infctx-validation-dryrun.yaml | 339 ------- .../infctx-validation-full.yaml | 339 ------- .../infctx-validation-last-segment.yaml | 339 ------- .../infctx-validation-segmented-512.yaml | 339 ------- .../infctx-validation-segmented.yaml | 339 ------- .../infctx-validation.ipynb | 837 ------------------ 7 files changed, 4 insertions(+), 2532 deletions(-) delete mode 100644 notebook/trainer-validation/infctx-validation-dryrun.yaml delete mode 100644 notebook/trainer-validation/infctx-validation-full.yaml delete mode 100644 notebook/trainer-validation/infctx-validation-last-segment.yaml delete mode 100644 notebook/trainer-validation/infctx-validation-segmented-512.yaml delete mode 100644 notebook/trainer-validation/infctx-validation-segmented.yaml delete mode 100644 notebook/trainer-validation/infctx-validation.ipynb diff --git a/.gitignore b/.gitignore index ed71484d..c47f6be8 100644 --- a/.gitignore +++ b/.gitignore @@ -153,6 +153,10 @@ datapath/ checkpoint/ node_modules/ +# We do capture the notebook generated .log files +# as they are meant to be read as reference +!notebook/**/*.log + # Ignore generated lightning logs and config files */lightning_logs/ */config.yaml \ No newline at end of file diff --git a/notebook/trainer-validation/infctx-validation-dryrun.yaml b/notebook/trainer-validation/infctx-validation-dryrun.yaml deleted file mode 100644 index ab4e3145..00000000 --- a/notebook/trainer-validation/infctx-validation-dryrun.yaml +++ /dev/null @@ -1,339 +0,0 @@ -# lightning.pytorch==2.0.2 -seed_everything: 3941088705 -trainer: - # Configure the number of GPU, avaliable on your machine - accelerator: gpu - devices: auto - num_nodes: 1 - - # - # Configure the deepspeed strategy, we recommend you start with `deepspeed_stage_2_offload` - # and adjust from there according to your training needs. `deepspeed_stage_3_offload` is useful - # for training LoRA on large models on a single GPU. - # - # In general you would want to use the following: - # - # - deepspeed_stage_1 : Each of your GPU has too much vram, and you do not know what to do - # - # - deepspeed_stage_2 : Optimal distributed training strategy, across multiple gpu each with sufficient vram - # - deepspeed_stage_2_offload : Reduce vram usage by offloading the optimizer state and work to cpu - # - # - deepspeed_stage_3 : Split up the model across multiple gpu, useful for large models, at a performance cost - # - deepspeed_stage_3_offload : Additional offloading, for even greater performance cost - # - # For more details see: - # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 - # - strategy: deepspeed_stage_3_offload - - # Floating point precision for the model, because RWKV is built FOR bf16 - # you should pretty much never change this setting - precision: bf16 - - # Logger setting for wandb, if you want to enable wandb, uncomment the whole logger section - # --- - # logger: - # class_path: lightning.pytorch.loggers.WandbLogger - # init_args: - # name: 'infctx-validation-dryrun (short 2 * 2 data sample dry run)' - # project: 'RWKV-Memory-Experiment' - # tags: ['RWKV', 'memory-exp'] - # id: null - # save_dir: . - # version: null - # offline: false - # dir: null - # anonymous: null - # log_model: false - # experiment: null - # prefix: '' - # checkpoint_name: null - # job_type: null - # config: null - # entity: null - # reinit: null - # group: null - # notes: null - # magic: null - # config_exclude_keys: null - # config_include_keys: null - # mode: null - # allow_val_change: null - # resume: null - # force: null - # tensorboard: null - # sync_tensorboard: null - # monitor_gym: null - # save_code: null - # settings: null - - # Checkpoint settings for the training process - callbacks: - - class_path: lightning.pytorch.callbacks.ModelCheckpoint - init_args: - # Configure this to the path you want to save your checkpoints to - # note that a subdir will be created with the name `epoch=x-step=y.ckpt` - # - # to convert a checkpoint to a model, you can use the - # `python3 export_checkpoint.py ` script, - # which will create a `rwkv_model.pth` in the checkpoint directory. - # - # Do not use the `zero_to_fp32.py` script as that will have export format issues - dirpath: ../checkpoint/trainer-validaiton/infctx-validation-dryrun - filename: null - - # Save the top/last K checkpoints - save_top_k: 3 - # Choose by the most recent checkpoints (step based) - monitor: 'step' - mode: max - - # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' - # useful to simply checkpoint resume scripts, at a price of disk performance - save_last: false - - # DO NOT set this as true, as the model weight exported will have format issues - # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead - save_weights_only: false - - # How frequent you want to save a checkpoint for every step. - # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches - # - # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) - # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process - # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes - every_n_train_steps: 2500 - every_n_epochs: null - save_on_train_epoch_end: true - train_time_interval: null - - # Other settings, you can probably leave alone - verbose: false - auto_insert_metric_name: true - - ######################################## - ## Training run parameter settings - ######################################## - - # Generally what you want to configure is the maximum number of epochs - # Leave it as -1, and it will keep going forever till interrupted - # Or set it as a number, and it will stop after that number of epochs - max_epochs: -1 - min_epochs: null - max_steps: 2 - min_steps: null - max_time: null - - # Number of datasamples to train for each step, a data sample is considered - # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" - # - # This decides the number of datasample, to learn together from, before backproping - # any weight changes at the end of the batch. - # - # Recommended to be a big enough number (like 128/256) where it prevents the training - # loss from flucuating in the process. But not too big of a number where the increased - # GPU vRAM / offloaded RAM usage will cause the training to crash. - # - # You are also recommended to configure this to a large enough number to fully utilize - # your GPU processing time %, and avoid idle time for the GPU between batches - accumulate_grad_batches: 2 - - # Various other settings, you probably want to leave alone - fast_dev_run: false - limit_train_batches: null - limit_val_batches: null - limit_test_batches: null - limit_predict_batches: null - overfit_batches: 0.0 - val_check_interval: null - check_val_every_n_epoch: 1 - num_sanity_val_steps: 0 - log_every_n_steps: 1 - enable_checkpointing: true - enable_progress_bar: null - enable_model_summary: null - gradient_clip_val: 1.0 - gradient_clip_algorithm: null - deterministic: null - benchmark: null - inference_mode: true - use_distributed_sampler: true - profiler: null - detect_anomaly: false - barebones: false - plugins: null - sync_batchnorm: false - reload_dataloaders_every_n_epochs: 0 - default_root_dir: null - -######################################## -## Training model settings -######################################## -model: - # Model to start the finetune/training process from - load_model: ../model/Echo-A-1B5-Init.pth - - # The model size setting, this MUST match - # your current model settings, refer to the model card - # of the downloaded model for more details - n_embd: 2048 - n_layer: 24 - vocab_size: 50277 - - # Context length to use for the training process - # the larger the number (and batch size) the larger the vram usage - # - # Note that if the datasample context length is larger then the ctx_len - # its training process would be split into ctx_len sized chunks. - # - # This allows the training of extreamly large context length (eg. 100k), - # without eating up too much vram by keeping the training context length - # to a resonable number sutible to the current GPU setup - ctx_len: 128 - - # Data samples would be cut down to the respective max ctx_len_cutoffs - # values if its larger then ctx_len. If the data sample is larger then - # the largest len_cutoff, the remaining data will be discarded - ctx_len_cutoffs: [1024, 2048, 4096, 8192, 16384, 32768, 65536] - # Experimental settings, number of tokens to skip in the data sample - # prefix, for the respective cutoff length. Used to speed up the process - ctx_len_warmup_steps: [0, 0, 0, 0, 0, 0, 0] - - # Learning rate of the training process - # --- - # Initia learning rate of the process - lr_init: 6e-4 - # Final learning rate after the learning rate period - # learning rate will stay at final value from then onwards - # - # NOTE: lr_final / lr_period does not work with warmup_steps - # and will be ignored (or replaced) with the warmup_steps logic instead - lr_final: 4e-4 - # Number of epoch to reduce the learning rate from lr_init to lr_final - # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) - # 0 means lr_final will apply immediately - # -1 means we take the current max_step / max_epoch as the period - lr_period: 1 - # lr_period type if its set, defaults to epoch - lr_period_type: epoch - - # Adam optimizer settings - # You probably want to leave this alone, unless you know what you are doing - beta1: 0.9 - beta2: 0.99 - adam_eps: 1.0e-08 - weight_decay: 0.01 - - # torch.set_float32_matmul_precision, used to optimize operations with tensor cores - # this should be set as null, for non cuda core GPUs - torch_set_float32_matmul_precision: 'high' - # torch_set_float32_matmul_precision: null - - # Segmented based learning, used to work around training of large context length - # beyond what can be supported by the current GPU vram architecture - # - # This is not 1:1 equivalent to the same training process with required vram - # as the training process is split into multiple segments, part by part. - # with limited learnings from the previous segment. - bptt_learning: true - - # Segmented range to performing backprop learning on - # 1 means to apply only for the last segment - # -1 means to apply for all segments - bptt_learning_range: -1 - - # various other settings you probably should leave alone - grad_cp: true - warmup_steps: -1 - layerwise_lr: true - dim_att: null - dim_ffn: null -data: - # dataset_path for the prebuilt dataset, using HF `load_from_disk()` - # - # Use this if you have built your own dataset and saved it with `save_to_disk()` - # with source left as null. Other wise configure this to a directory which the - # dataset will be built and tokenized by the huggingface dataset process. - data_path: ../datapath/enwiki_10k_1024/ - - # Other wise provide the source path, which is used as huggingface dataset path - # this will be used to populate the dataset_path - # - # Use either the following - # - hugging face dataset - # - Directory path to a directory containing dataset files - # - Path to a single dataset file - # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) - # - null - # - # If source is disabled, all other params, except data_path, is ignored - source: "teven/enwiki_10k" - # source: text - # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt - - # Use data_dir, if you are using source=text/json/etc - # this should be relative to the data_path - source_data_dir: null - - # After loading the dataset, split out test data used for validation, - # This process is skipped if the dataset includes a test split - # This process is skipped if set to zero - test_split: 0.01 - test_split_shuffle: false - - # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer - # If using a custom tokenizer, provide the tokenizer file path - # --- - tokenizer: neox - - # Minimum / Maximum token size of the dataset to use - # useful for filtering out small noisy data samples from large datasets - # (eg. removal of small articles of less then 512 tokens from wikipedia) - # - # This is ignored, if set to -1 - min_token_size: 64 - max_token_size: -1 - - # Rechunking of text dataset, this is done only when source is set as 'text' - # and will merge the various sentencees, into larger chunks up to the target size - # - # Defaults to 4096 - # - # This is ignored, if source is not set as text - # This is ignored, if set to zero - # --- - text_rechunk_size: 1024 - - # Apply text rechunk to the dataset, even if its not a 'text' source - # This is done only after dataset filtering, and if source is not 'text' - # --- - text_rechunk_force: true - - # Custom text column to use, useful for dataset with alternative training columns labels - # This is checked before multi column merging, default is null (disabled) - # eg: 'code' - # --- - # custom_text_key: 'code' - - # Multi Column merging process, default setting is used to support and merge - # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] - # - # A minimum of 2 columns is required, with non empty data, for the merge to occur - # If no match is found, this will fallback to the default prompt/completion or text column, - # or throw an error if the default fallback is not found - # --- - # multi_column_keys: ['instruction', 'input', 'output'] - # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] - # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' - - # If processing prompt/completion jsonl pairs, the prompt is masked by default - # use this flag to disable this default behaviour - # --- - # disable_prompt_mask: false - -# Path to the current checkpoint to continue training from -# Enable this to the last checkpoint after the first run -# (if it crash and you want to resume) -# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-dryrun/epoch=0-step=20.ckpt -ckpt_path: null diff --git a/notebook/trainer-validation/infctx-validation-full.yaml b/notebook/trainer-validation/infctx-validation-full.yaml deleted file mode 100644 index a4a5dc1d..00000000 --- a/notebook/trainer-validation/infctx-validation-full.yaml +++ /dev/null @@ -1,339 +0,0 @@ -# lightning.pytorch==2.0.2 -seed_everything: 3941088705 -trainer: - # Configure the number of GPU, avaliable on your machine - accelerator: gpu - devices: 1 - num_nodes: 1 - - # - # Configure the deepspeed strategy, we recommend you start with `deepspeed_stage_2_offload` - # and adjust from there according to your training needs. `deepspeed_stage_3_offload` is useful - # for training LoRA on large models on a single GPU. - # - # In general you would want to use the following: - # - # - deepspeed_stage_1 : Each of your GPU has too much vram, and you do not know what to do - # - # - deepspeed_stage_2 : Optimal distributed training strategy, across multiple gpu each with sufficient vram - # - deepspeed_stage_2_offload : Reduce vram usage by offloading the optimizer state and work to cpu - # - # - deepspeed_stage_3 : Split up the model across multiple gpu, useful for large models, at a performance cost - # - deepspeed_stage_3_offload : Additional offloading, for even greater performance cost - # - # For more details see: - # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 - # - strategy: deepspeed_stage_2_offload - - # Floating point precision for the model, because RWKV is built FOR bf16 - # you should pretty much never change this setting - precision: bf16 - - # Logger setting for wandb, if you want to enable wandb, uncomment the whole logger section - # --- - logger: - class_path: lightning.pytorch.loggers.WandbLogger - init_args: - name: 'infctx-validation-full (train-ctx=1024, data-ctx=1024, bs=12)' - project: 'RWKV-infctx-validation' - tags: ['RWKV', 'infctx'] - id: null - save_dir: . - version: null - offline: false - dir: null - anonymous: null - log_model: false - experiment: null - prefix: '' - checkpoint_name: null - job_type: null - config: null - entity: null - reinit: null - group: null - notes: null - magic: null - config_exclude_keys: null - config_include_keys: null - mode: null - allow_val_change: null - resume: null - force: null - tensorboard: null - sync_tensorboard: null - monitor_gym: null - save_code: null - settings: null - - # Checkpoint settings for the training process - callbacks: - - class_path: lightning.pytorch.callbacks.ModelCheckpoint - init_args: - # Configure this to the path you want to save your checkpoints to - # note that a subdir will be created with the name `epoch=x-step=y.ckpt` - # - # to convert a checkpoint to a model, you can use the - # `python3 export_checkpoint.py ` script, - # which will create a `rwkv_model.pth` in the checkpoint directory. - # - # Do not use the `zero_to_fp32.py` script as that will have export format issues - dirpath: ../checkpoint/trainer-validaiton/infctx-validation-full - filename: null - - # Save the top/last K checkpoints - save_top_k: 3 - # Choose by the most recent checkpoints (step based) - monitor: 'step' - mode: max - - # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' - # useful to simply checkpoint resume scripts, at a price of disk performance - save_last: false - - # DO NOT set this as true, as the model weight exported will have format issues - # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead - save_weights_only: false - - # How frequent you want to save a checkpoint for every step. - # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches - # - # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) - # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process - # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes - every_n_train_steps: 5000 - every_n_epochs: null - save_on_train_epoch_end: true - train_time_interval: null - - # Other settings, you can probably leave alone - verbose: false - auto_insert_metric_name: true - - ######################################## - ## Training run parameter settings - ######################################## - - # Generally what you want to configure is the maximum number of epochs - # Leave it as -1, and it will keep going forever till interrupted - # Or set it as a number, and it will stop after that number of epochs - max_epochs: 1 - min_epochs: null - max_steps: -1 - min_steps: null - max_time: null - - # Number of datasamples to train for each step, a data sample is considered - # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" - # - # This decides the number of datasample, to learn together from, before backproping - # any weight changes at the end of the batch. - # - # Recommended to be a big enough number (like 128/256) where it prevents the training - # loss from flucuating in the process. But not too big of a number where the increased - # GPU vRAM / offloaded RAM usage will cause the training to crash. - # - # You are also recommended to configure this to a large enough number to fully utilize - # your GPU processing time %, and avoid idle time for the GPU between batches - accumulate_grad_batches: 12 - - # Various other settings, you probably want to leave alone - fast_dev_run: false - limit_train_batches: null - limit_val_batches: null - limit_test_batches: null - limit_predict_batches: null - overfit_batches: 0.0 - val_check_interval: null - check_val_every_n_epoch: 1 - num_sanity_val_steps: 0 - log_every_n_steps: 1 - enable_checkpointing: true - enable_progress_bar: null - enable_model_summary: null - gradient_clip_val: 1.0 - gradient_clip_algorithm: null - deterministic: null - benchmark: null - inference_mode: true - use_distributed_sampler: true - profiler: null - detect_anomaly: false - barebones: false - plugins: null - sync_batchnorm: false - reload_dataloaders_every_n_epochs: 0 - default_root_dir: null - -######################################## -## Training model settings -######################################## -model: - # Model to start the finetune/training process from - load_model: ../model/Echo-A-1B5-Init.pth - - # The model size setting, this MUST match - # your current model settings, refer to the model card - # of the downloaded model for more details - n_embd: 2048 - n_layer: 24 - vocab_size: 50277 - - # Context length to use for the training process - # the larger the number (and batch size) the larger the vram usage - # - # Note that if the datasample context length is larger then the ctx_len - # its training process would be split into ctx_len sized chunks. - # - # This allows the training of extreamly large context length (eg. 100k), - # without eating up too much vram by keeping the training context length - # to a resonable number sutible to the current GPU setup - ctx_len: 1024 - - # Data samples would be cut down to the respective max ctx_len_cutoffs - # values if its larger then ctx_len. If the data sample is larger then - # the largest len_cutoff, the remaining data will be discarded - ctx_len_cutoffs: [1024, 2048, 4096, 8192, 16384, 32768, 65536] - # Experimental settings, number of tokens to skip in the data sample - # prefix, for the respective cutoff length. Used to speed up the process - ctx_len_warmup_steps: [0, 0, 0, 0, 0, 0, 0] - - # Learning rate of the training process - # --- - # Initia learning rate of the process - lr_init: 6e-4 - # Final learning rate after the learning rate period - # learning rate will stay at final value from then onwards - # - # NOTE: lr_final / lr_period does not work with warmup_steps - # and will be ignored (or replaced) with the warmup_steps logic instead - lr_final: 4e-4 - # Number of epoch to reduce the learning rate from lr_init to lr_final - # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) - # 0 means lr_final will apply immediately - # -1 means we take the current max_step / max_epoch as the period - lr_period: 1 - # lr_period type if its set, defaults to epoch - lr_period_type: epoch - - # Adam optimizer settings - # You probably want to leave this alone, unless you know what you are doing - beta1: 0.9 - beta2: 0.99 - adam_eps: 1.0e-08 - weight_decay: 0.01 - - # torch.set_float32_matmul_precision, used to optimize operations with tensor cores - # this should be set as null, for non cuda core GPUs - torch_set_float32_matmul_precision: 'high' - # torch_set_float32_matmul_precision: null - - # Segmented based learning, used to work around training of large context length - # beyond what can be supported by the current GPU vram architecture - # - # This is not 1:1 equivalent to the same training process with required vram - # as the training process is split into multiple segments, part by part. - # with limited learnings from the previous segment. - bptt_learning: false - - # Segmented range to performing backprop learning on - # 1 means to apply only for the last segment - # -1 means to apply for all segments - bptt_learning_range: -1 - - # various other settings you probably should leave alone - grad_cp: true - warmup_steps: -1 - layerwise_lr: true - dim_att: null - dim_ffn: null -data: - # dataset_path for the prebuilt dataset, using HF `load_from_disk()` - # - # Use this if you have built your own dataset and saved it with `save_to_disk()` - # with source left as null. Other wise configure this to a directory which the - # dataset will be built and tokenized by the huggingface dataset process. - data_path: ../datapath/enwiki_10k_1024/ - - # Other wise provide the source path, which is used as huggingface dataset path - # this will be used to populate the dataset_path - # - # Use either the following - # - hugging face dataset - # - Directory path to a directory containing dataset files - # - Path to a single dataset file - # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) - # - null - # - # If source is disabled, all other params, except data_path, is ignored - source: "teven/enwiki_10k" - # source: text - # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt - - # Use data_dir, if you are using source=text/json/etc - # this should be relative to the data_path - source_data_dir: null - - # After loading the dataset, split out test data used for validation, - # This process is skipped if the dataset includes a test split - # This process is skipped if set to zero - test_split: 0.01 - test_split_shuffle: false - - # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer - # If using a custom tokenizer, provide the tokenizer file path - # --- - tokenizer: neox - - # Minimum / Maximum token size of the dataset to use - # useful for filtering out small noisy data samples from large datasets - # (eg. removal of small articles of less then 512 tokens from wikipedia) - # - # This is ignored, if set to -1 - min_token_size: 64 - max_token_size: -1 - - # Rechunking of text dataset, this is done only when source is set as 'text' - # and will merge the various sentencees, into larger chunks up to the target size - # - # Defaults to 4096 - # - # This is ignored, if source is not set as text - # This is ignored, if set to zero - # --- - text_rechunk_size: 1024 - - # Apply text rechunk to the dataset, even if its not a 'text' source - # This is done only after dataset filtering, and if source is not 'text' - # --- - text_rechunk_force: true - - # Custom text column to use, useful for dataset with alternative training columns labels - # This is checked before multi column merging, default is null (disabled) - # eg: 'code' - # --- - # custom_text_key: 'code' - - # Multi Column merging process, default setting is used to support and merge - # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] - # - # A minimum of 2 columns is required, with non empty data, for the merge to occur - # If no match is found, this will fallback to the default prompt/completion or text column, - # or throw an error if the default fallback is not found - # --- - # multi_column_keys: ['instruction', 'input', 'output'] - # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] - # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' - - # If processing prompt/completion jsonl pairs, the prompt is masked by default - # use this flag to disable this default behaviour - # --- - # disable_prompt_mask: false - -# Path to the current checkpoint to continue training from -# Enable this to the last checkpoint after the first run -# (if it crash and you want to resume) -# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-dryrun/epoch=0-step=20.ckpt -ckpt_path: null diff --git a/notebook/trainer-validation/infctx-validation-last-segment.yaml b/notebook/trainer-validation/infctx-validation-last-segment.yaml deleted file mode 100644 index dd3ded07..00000000 --- a/notebook/trainer-validation/infctx-validation-last-segment.yaml +++ /dev/null @@ -1,339 +0,0 @@ -# lightning.pytorch==2.0.2 -seed_everything: 3941088705 -trainer: - # Configure the number of GPU, avaliable on your machine - accelerator: gpu - devices: 1 - num_nodes: 1 - - # - # Configure the deepspeed strategy, we recommend you start with `deepspeed_stage_2_offload` - # and adjust from there according to your training needs. `deepspeed_stage_3_offload` is useful - # for training LoRA on large models on a single GPU. - # - # In general you would want to use the following: - # - # - deepspeed_stage_1 : Each of your GPU has too much vram, and you do not know what to do - # - # - deepspeed_stage_2 : Optimal distributed training strategy, across multiple gpu each with sufficient vram - # - deepspeed_stage_2_offload : Reduce vram usage by offloading the optimizer state and work to cpu - # - # - deepspeed_stage_3 : Split up the model across multiple gpu, useful for large models, at a performance cost - # - deepspeed_stage_3_offload : Additional offloading, for even greater performance cost - # - # For more details see: - # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 - # - strategy: deepspeed_stage_2_offload - - # Floating point precision for the model, because RWKV is built FOR bf16 - # you should pretty much never change this setting - precision: bf16 - - # Logger setting for wandb, if you want to enable wandb, uncomment the whole logger section - # --- - logger: - class_path: lightning.pytorch.loggers.WandbLogger - init_args: - name: 'infctx-validation-last-segment (train-ctx=128, data-ctx=1024, bs=12)' - project: 'RWKV-infctx-validation' - tags: ['RWKV', 'infctx'] - id: null - save_dir: . - version: null - offline: false - dir: null - anonymous: null - log_model: false - experiment: null - prefix: '' - checkpoint_name: null - job_type: null - config: null - entity: null - reinit: null - group: null - notes: null - magic: null - config_exclude_keys: null - config_include_keys: null - mode: null - allow_val_change: null - resume: null - force: null - tensorboard: null - sync_tensorboard: null - monitor_gym: null - save_code: null - settings: null - - # Checkpoint settings for the training process - callbacks: - - class_path: lightning.pytorch.callbacks.ModelCheckpoint - init_args: - # Configure this to the path you want to save your checkpoints to - # note that a subdir will be created with the name `epoch=x-step=y.ckpt` - # - # to convert a checkpoint to a model, you can use the - # `python3 export_checkpoint.py ` script, - # which will create a `rwkv_model.pth` in the checkpoint directory. - # - # Do not use the `zero_to_fp32.py` script as that will have export format issues - dirpath: ../checkpoint/trainer-validaiton/infctx-validation-last-segment - filename: null - - # Save the top/last K checkpoints - save_top_k: 3 - # Choose by the most recent checkpoints (step based) - monitor: 'step' - mode: max - - # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' - # useful to simply checkpoint resume scripts, at a price of disk performance - save_last: false - - # DO NOT set this as true, as the model weight exported will have format issues - # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead - save_weights_only: false - - # How frequent you want to save a checkpoint for every step. - # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches - # - # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) - # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process - # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes - every_n_train_steps: 5000 - every_n_epochs: null - save_on_train_epoch_end: true - train_time_interval: null - - # Other settings, you can probably leave alone - verbose: false - auto_insert_metric_name: true - - ######################################## - ## Training run parameter settings - ######################################## - - # Generally what you want to configure is the maximum number of epochs - # Leave it as -1, and it will keep going forever till interrupted - # Or set it as a number, and it will stop after that number of epochs - max_epochs: 1 - min_epochs: null - max_steps: -1 - min_steps: null - max_time: null - - # Number of datasamples to train for each step, a data sample is considered - # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" - # - # This decides the number of datasample, to learn together from, before backproping - # any weight changes at the end of the batch. - # - # Recommended to be a big enough number (like 128/256) where it prevents the training - # loss from flucuating in the process. But not too big of a number where the increased - # GPU vRAM / offloaded RAM usage will cause the training to crash. - # - # You are also recommended to configure this to a large enough number to fully utilize - # your GPU processing time %, and avoid idle time for the GPU between batches - accumulate_grad_batches: 12 - - # Various other settings, you probably want to leave alone - fast_dev_run: false - limit_train_batches: null - limit_val_batches: null - limit_test_batches: null - limit_predict_batches: null - overfit_batches: 0.0 - val_check_interval: null - check_val_every_n_epoch: 1 - num_sanity_val_steps: 0 - log_every_n_steps: 1 - enable_checkpointing: true - enable_progress_bar: null - enable_model_summary: null - gradient_clip_val: 1.0 - gradient_clip_algorithm: null - deterministic: null - benchmark: null - inference_mode: true - use_distributed_sampler: true - profiler: null - detect_anomaly: false - barebones: false - plugins: null - sync_batchnorm: false - reload_dataloaders_every_n_epochs: 0 - default_root_dir: null - -######################################## -## Training model settings -######################################## -model: - # Model to start the finetune/training process from - load_model: ../model/Echo-A-1B5-Init.pth - - # The model size setting, this MUST match - # your current model settings, refer to the model card - # of the downloaded model for more details - n_embd: 2048 - n_layer: 24 - vocab_size: 50277 - - # Context length to use for the training process - # the larger the number (and batch size) the larger the vram usage - # - # Note that if the datasample context length is larger then the ctx_len - # its training process would be split into ctx_len sized chunks. - # - # This allows the training of extreamly large context length (eg. 100k), - # without eating up too much vram by keeping the training context length - # to a resonable number sutible to the current GPU setup - ctx_len: 128 - - # Data samples would be cut down to the respective max ctx_len_cutoffs - # values if its larger then ctx_len. If the data sample is larger then - # the largest len_cutoff, the remaining data will be discarded - ctx_len_cutoffs: [1024, 2048, 4096, 8192, 16384, 32768, 65536] - # Experimental settings, number of tokens to skip in the data sample - # prefix, for the respective cutoff length. Used to speed up the process - ctx_len_warmup_steps: [0, 0, 0, 0, 0, 0, 0] - - # Learning rate of the training process - # --- - # Initia learning rate of the process - lr_init: 6e-4 - # Final learning rate after the learning rate period - # learning rate will stay at final value from then onwards - # - # NOTE: lr_final / lr_period does not work with warmup_steps - # and will be ignored (or replaced) with the warmup_steps logic instead - lr_final: 4e-4 - # Number of epoch to reduce the learning rate from lr_init to lr_final - # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) - # 0 means lr_final will apply immediately - # -1 means we take the current max_step / max_epoch as the period - lr_period: 1 - # lr_period type if its set, defaults to epoch - lr_period_type: epoch - - # Adam optimizer settings - # You probably want to leave this alone, unless you know what you are doing - beta1: 0.9 - beta2: 0.99 - adam_eps: 1.0e-08 - weight_decay: 0.01 - - # torch.set_float32_matmul_precision, used to optimize operations with tensor cores - # this should be set as null, for non cuda core GPUs - torch_set_float32_matmul_precision: 'high' - # torch_set_float32_matmul_precision: null - - # Segmented based learning, used to work around training of large context length - # beyond what can be supported by the current GPU vram architecture - # - # This is not 1:1 equivalent to the same training process with required vram - # as the training process is split into multiple segments, part by part. - # with limited learnings from the previous segment. - bptt_learning: true - - # Segmented range to performing backprop learning on - # 1 means to apply only for the last segment - # -1 means to apply for all segments - bptt_learning_range: 1 - - # various other settings you probably should leave alone - grad_cp: true - warmup_steps: -1 - layerwise_lr: true - dim_att: null - dim_ffn: null -data: - # dataset_path for the prebuilt dataset, using HF `load_from_disk()` - # - # Use this if you have built your own dataset and saved it with `save_to_disk()` - # with source left as null. Other wise configure this to a directory which the - # dataset will be built and tokenized by the huggingface dataset process. - data_path: ../datapath/enwiki_10k_1024/ - - # Other wise provide the source path, which is used as huggingface dataset path - # this will be used to populate the dataset_path - # - # Use either the following - # - hugging face dataset - # - Directory path to a directory containing dataset files - # - Path to a single dataset file - # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) - # - null - # - # If source is disabled, all other params, except data_path, is ignored - source: "teven/enwiki_10k" - # source: text - # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt - - # Use data_dir, if you are using source=text/json/etc - # this should be relative to the data_path - source_data_dir: null - - # After loading the dataset, split out test data used for validation, - # This process is skipped if the dataset includes a test split - # This process is skipped if set to zero - test_split: 0.01 - test_split_shuffle: false - - # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer - # If using a custom tokenizer, provide the tokenizer file path - # --- - tokenizer: neox - - # Minimum / Maximum token size of the dataset to use - # useful for filtering out small noisy data samples from large datasets - # (eg. removal of small articles of less then 512 tokens from wikipedia) - # - # This is ignored, if set to -1 - min_token_size: 64 - max_token_size: -1 - - # Rechunking of text dataset, this is done only when source is set as 'text' - # and will merge the various sentencees, into larger chunks up to the target size - # - # Defaults to 4096 - # - # This is ignored, if source is not set as text - # This is ignored, if set to zero - # --- - text_rechunk_size: 1024 - - # Apply text rechunk to the dataset, even if its not a 'text' source - # This is done only after dataset filtering, and if source is not 'text' - # --- - text_rechunk_force: true - - # Custom text column to use, useful for dataset with alternative training columns labels - # This is checked before multi column merging, default is null (disabled) - # eg: 'code' - # --- - # custom_text_key: 'code' - - # Multi Column merging process, default setting is used to support and merge - # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] - # - # A minimum of 2 columns is required, with non empty data, for the merge to occur - # If no match is found, this will fallback to the default prompt/completion or text column, - # or throw an error if the default fallback is not found - # --- - # multi_column_keys: ['instruction', 'input', 'output'] - # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] - # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' - - # If processing prompt/completion jsonl pairs, the prompt is masked by default - # use this flag to disable this default behaviour - # --- - # disable_prompt_mask: false - -# Path to the current checkpoint to continue training from -# Enable this to the last checkpoint after the first run -# (if it crash and you want to resume) -# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-dryrun/epoch=0-step=20.ckpt -ckpt_path: null diff --git a/notebook/trainer-validation/infctx-validation-segmented-512.yaml b/notebook/trainer-validation/infctx-validation-segmented-512.yaml deleted file mode 100644 index 3b8f015c..00000000 --- a/notebook/trainer-validation/infctx-validation-segmented-512.yaml +++ /dev/null @@ -1,339 +0,0 @@ -# lightning.pytorch==2.0.2 -seed_everything: 3941088705 -trainer: - # Configure the number of GPU, avaliable on your machine - accelerator: gpu - devices: 1 - num_nodes: 1 - - # - # Configure the deepspeed strategy, we recommend you start with `deepspeed_stage_2_offload` - # and adjust from there according to your training needs. `deepspeed_stage_3_offload` is useful - # for training LoRA on large models on a single GPU. - # - # In general you would want to use the following: - # - # - deepspeed_stage_1 : Each of your GPU has too much vram, and you do not know what to do - # - # - deepspeed_stage_2 : Optimal distributed training strategy, across multiple gpu each with sufficient vram - # - deepspeed_stage_2_offload : Reduce vram usage by offloading the optimizer state and work to cpu - # - # - deepspeed_stage_3 : Split up the model across multiple gpu, useful for large models, at a performance cost - # - deepspeed_stage_3_offload : Additional offloading, for even greater performance cost - # - # For more details see: - # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 - # - strategy: deepspeed_stage_2_offload - - # Floating point precision for the model, because RWKV is built FOR bf16 - # you should pretty much never change this setting - precision: bf16 - - # Logger setting for wandb, if you want to enable wandb, uncomment the whole logger section - # --- - logger: - class_path: lightning.pytorch.loggers.WandbLogger - init_args: - name: 'infctx-validation-512-segmented (train-ctx=512, data-ctx=1024, bs=12)' - project: 'RWKV-infctx-validation' - tags: ['RWKV', 'infctx'] - id: null - save_dir: . - version: null - offline: false - dir: null - anonymous: null - log_model: false - experiment: null - prefix: '' - checkpoint_name: null - job_type: null - config: null - entity: null - reinit: null - group: null - notes: null - magic: null - config_exclude_keys: null - config_include_keys: null - mode: null - allow_val_change: null - resume: null - force: null - tensorboard: null - sync_tensorboard: null - monitor_gym: null - save_code: null - settings: null - - # Checkpoint settings for the training process - callbacks: - - class_path: lightning.pytorch.callbacks.ModelCheckpoint - init_args: - # Configure this to the path you want to save your checkpoints to - # note that a subdir will be created with the name `epoch=x-step=y.ckpt` - # - # to convert a checkpoint to a model, you can use the - # `python3 export_checkpoint.py ` script, - # which will create a `rwkv_model.pth` in the checkpoint directory. - # - # Do not use the `zero_to_fp32.py` script as that will have export format issues - dirpath: ../checkpoint/trainer-validaiton/infctx-validation-segment-512 - filename: null - - # Save the top/last K checkpoints - save_top_k: 3 - # Choose by the most recent checkpoints (step based) - monitor: 'step' - mode: max - - # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' - # useful to simply checkpoint resume scripts, at a price of disk performance - save_last: false - - # DO NOT set this as true, as the model weight exported will have format issues - # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead - save_weights_only: false - - # How frequent you want to save a checkpoint for every step. - # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches - # - # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) - # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process - # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes - every_n_train_steps: 5000 - every_n_epochs: null - save_on_train_epoch_end: true - train_time_interval: null - - # Other settings, you can probably leave alone - verbose: false - auto_insert_metric_name: true - - ######################################## - ## Training run parameter settings - ######################################## - - # Generally what you want to configure is the maximum number of epochs - # Leave it as -1, and it will keep going forever till interrupted - # Or set it as a number, and it will stop after that number of epochs - max_epochs: 1 - min_epochs: null - max_steps: -1 - min_steps: null - max_time: null - - # Number of datasamples to train for each step, a data sample is considered - # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" - # - # This decides the number of datasample, to learn together from, before backproping - # any weight changes at the end of the batch. - # - # Recommended to be a big enough number (like 128/256) where it prevents the training - # loss from flucuating in the process. But not too big of a number where the increased - # GPU vRAM / offloaded RAM usage will cause the training to crash. - # - # You are also recommended to configure this to a large enough number to fully utilize - # your GPU processing time %, and avoid idle time for the GPU between batches - accumulate_grad_batches: 12 - - # Various other settings, you probably want to leave alone - fast_dev_run: false - limit_train_batches: null - limit_val_batches: null - limit_test_batches: null - limit_predict_batches: null - overfit_batches: 0.0 - val_check_interval: null - check_val_every_n_epoch: 1 - num_sanity_val_steps: 0 - log_every_n_steps: 1 - enable_checkpointing: true - enable_progress_bar: null - enable_model_summary: null - gradient_clip_val: 1.0 - gradient_clip_algorithm: null - deterministic: null - benchmark: null - inference_mode: true - use_distributed_sampler: true - profiler: null - detect_anomaly: false - barebones: false - plugins: null - sync_batchnorm: false - reload_dataloaders_every_n_epochs: 0 - default_root_dir: null - -######################################## -## Training model settings -######################################## -model: - # Model to start the finetune/training process from - load_model: ../model/Echo-A-1B5-Init.pth - - # The model size setting, this MUST match - # your current model settings, refer to the model card - # of the downloaded model for more details - n_embd: 2048 - n_layer: 24 - vocab_size: 50277 - - # Context length to use for the training process - # the larger the number (and batch size) the larger the vram usage - # - # Note that if the datasample context length is larger then the ctx_len - # its training process would be split into ctx_len sized chunks. - # - # This allows the training of extreamly large context length (eg. 100k), - # without eating up too much vram by keeping the training context length - # to a resonable number sutible to the current GPU setup - ctx_len: 512 - - # Data samples would be cut down to the respective max ctx_len_cutoffs - # values if its larger then ctx_len. If the data sample is larger then - # the largest len_cutoff, the remaining data will be discarded - ctx_len_cutoffs: [1024, 2048, 4096, 8192, 16384, 32768, 65536] - # Experimental settings, number of tokens to skip in the data sample - # prefix, for the respective cutoff length. Used to speed up the process - ctx_len_warmup_steps: [0, 0, 0, 0, 0, 0, 0] - - # Learning rate of the training process - # --- - # Initia learning rate of the process - lr_init: 6e-4 - # Final learning rate after the learning rate period - # learning rate will stay at final value from then onwards - # - # NOTE: lr_final / lr_period does not work with warmup_steps - # and will be ignored (or replaced) with the warmup_steps logic instead - lr_final: 4e-4 - # Number of epoch to reduce the learning rate from lr_init to lr_final - # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) - # 0 means lr_final will apply immediately - # -1 means we take the current max_step / max_epoch as the period - lr_period: 1 - # lr_period type if its set, defaults to epoch - lr_period_type: epoch - - # Adam optimizer settings - # You probably want to leave this alone, unless you know what you are doing - beta1: 0.9 - beta2: 0.99 - adam_eps: 1.0e-08 - weight_decay: 0.01 - - # torch.set_float32_matmul_precision, used to optimize operations with tensor cores - # this should be set as null, for non cuda core GPUs - torch_set_float32_matmul_precision: 'high' - # torch_set_float32_matmul_precision: null - - # Segmented based learning, used to work around training of large context length - # beyond what can be supported by the current GPU vram architecture - # - # This is not 1:1 equivalent to the same training process with required vram - # as the training process is split into multiple segments, part by part. - # with limited learnings from the previous segment. - bptt_learning: true - - # Segmented range to performing backprop learning on - # 1 means to apply only for the last segment - # -1 means to apply for all segments - bptt_learning_range: 1 - - # various other settings you probably should leave alone - grad_cp: true - warmup_steps: -1 - layerwise_lr: true - dim_att: null - dim_ffn: null -data: - # dataset_path for the prebuilt dataset, using HF `load_from_disk()` - # - # Use this if you have built your own dataset and saved it with `save_to_disk()` - # with source left as null. Other wise configure this to a directory which the - # dataset will be built and tokenized by the huggingface dataset process. - data_path: ../datapath/enwiki_10k_1024/ - - # Other wise provide the source path, which is used as huggingface dataset path - # this will be used to populate the dataset_path - # - # Use either the following - # - hugging face dataset - # - Directory path to a directory containing dataset files - # - Path to a single dataset file - # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) - # - null - # - # If source is disabled, all other params, except data_path, is ignored - source: "teven/enwiki_10k" - # source: text - # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt - - # Use data_dir, if you are using source=text/json/etc - # this should be relative to the data_path - source_data_dir: null - - # After loading the dataset, split out test data used for validation, - # This process is skipped if the dataset includes a test split - # This process is skipped if set to zero - test_split: 0.01 - test_split_shuffle: false - - # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer - # If using a custom tokenizer, provide the tokenizer file path - # --- - tokenizer: neox - - # Minimum / Maximum token size of the dataset to use - # useful for filtering out small noisy data samples from large datasets - # (eg. removal of small articles of less then 512 tokens from wikipedia) - # - # This is ignored, if set to -1 - min_token_size: 64 - max_token_size: -1 - - # Rechunking of text dataset, this is done only when source is set as 'text' - # and will merge the various sentencees, into larger chunks up to the target size - # - # Defaults to 4096 - # - # This is ignored, if source is not set as text - # This is ignored, if set to zero - # --- - text_rechunk_size: 1024 - - # Apply text rechunk to the dataset, even if its not a 'text' source - # This is done only after dataset filtering, and if source is not 'text' - # --- - text_rechunk_force: true - - # Custom text column to use, useful for dataset with alternative training columns labels - # This is checked before multi column merging, default is null (disabled) - # eg: 'code' - # --- - # custom_text_key: 'code' - - # Multi Column merging process, default setting is used to support and merge - # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] - # - # A minimum of 2 columns is required, with non empty data, for the merge to occur - # If no match is found, this will fallback to the default prompt/completion or text column, - # or throw an error if the default fallback is not found - # --- - # multi_column_keys: ['instruction', 'input', 'output'] - # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] - # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' - - # If processing prompt/completion jsonl pairs, the prompt is masked by default - # use this flag to disable this default behaviour - # --- - # disable_prompt_mask: false - -# Path to the current checkpoint to continue training from -# Enable this to the last checkpoint after the first run -# (if it crash and you want to resume) -# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-dryrun/epoch=0-step=20.ckpt -ckpt_path: null diff --git a/notebook/trainer-validation/infctx-validation-segmented.yaml b/notebook/trainer-validation/infctx-validation-segmented.yaml deleted file mode 100644 index d278052e..00000000 --- a/notebook/trainer-validation/infctx-validation-segmented.yaml +++ /dev/null @@ -1,339 +0,0 @@ -# lightning.pytorch==2.0.2 -seed_everything: 3941088705 -trainer: - # Configure the number of GPU, avaliable on your machine - accelerator: gpu - devices: 1 - num_nodes: 1 - - # - # Configure the deepspeed strategy, we recommend you start with `deepspeed_stage_2_offload` - # and adjust from there according to your training needs. `deepspeed_stage_3_offload` is useful - # for training LoRA on large models on a single GPU. - # - # In general you would want to use the following: - # - # - deepspeed_stage_1 : Each of your GPU has too much vram, and you do not know what to do - # - # - deepspeed_stage_2 : Optimal distributed training strategy, across multiple gpu each with sufficient vram - # - deepspeed_stage_2_offload : Reduce vram usage by offloading the optimizer state and work to cpu - # - # - deepspeed_stage_3 : Split up the model across multiple gpu, useful for large models, at a performance cost - # - deepspeed_stage_3_offload : Additional offloading, for even greater performance cost - # - # For more details see: - # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 - # - strategy: deepspeed_stage_2_offload - - # Floating point precision for the model, because RWKV is built FOR bf16 - # you should pretty much never change this setting - precision: bf16 - - # Logger setting for wandb, if you want to enable wandb, uncomment the whole logger section - # --- - logger: - class_path: lightning.pytorch.loggers.WandbLogger - init_args: - name: 'infctx-validation-segmented (train-ctx=128, data-ctx=1024, bs=12)' - project: 'RWKV-infctx-validation' - tags: ['RWKV', 'infctx'] - id: null - save_dir: . - version: null - offline: false - dir: null - anonymous: null - log_model: false - experiment: null - prefix: '' - checkpoint_name: null - job_type: null - config: null - entity: null - reinit: null - group: null - notes: null - magic: null - config_exclude_keys: null - config_include_keys: null - mode: null - allow_val_change: null - resume: null - force: null - tensorboard: null - sync_tensorboard: null - monitor_gym: null - save_code: null - settings: null - - # Checkpoint settings for the training process - callbacks: - - class_path: lightning.pytorch.callbacks.ModelCheckpoint - init_args: - # Configure this to the path you want to save your checkpoints to - # note that a subdir will be created with the name `epoch=x-step=y.ckpt` - # - # to convert a checkpoint to a model, you can use the - # `python3 export_checkpoint.py ` script, - # which will create a `rwkv_model.pth` in the checkpoint directory. - # - # Do not use the `zero_to_fp32.py` script as that will have export format issues - dirpath: ../checkpoint/trainer-validaiton/infctx-validation-segmented - filename: null - - # Save the top/last K checkpoints - save_top_k: 3 - # Choose by the most recent checkpoints (step based) - monitor: 'step' - mode: max - - # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' - # useful to simply checkpoint resume scripts, at a price of disk performance - save_last: false - - # DO NOT set this as true, as the model weight exported will have format issues - # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead - save_weights_only: false - - # How frequent you want to save a checkpoint for every step. - # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches - # - # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) - # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process - # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes - every_n_train_steps: 5000 - every_n_epochs: null - save_on_train_epoch_end: true - train_time_interval: null - - # Other settings, you can probably leave alone - verbose: false - auto_insert_metric_name: true - - ######################################## - ## Training run parameter settings - ######################################## - - # Generally what you want to configure is the maximum number of epochs - # Leave it as -1, and it will keep going forever till interrupted - # Or set it as a number, and it will stop after that number of epochs - max_epochs: 1 - min_epochs: null - max_steps: -1 - min_steps: null - max_time: null - - # Number of datasamples to train for each step, a data sample is considered - # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" - # - # This decides the number of datasample, to learn together from, before backproping - # any weight changes at the end of the batch. - # - # Recommended to be a big enough number (like 128/256) where it prevents the training - # loss from flucuating in the process. But not too big of a number where the increased - # GPU vRAM / offloaded RAM usage will cause the training to crash. - # - # You are also recommended to configure this to a large enough number to fully utilize - # your GPU processing time %, and avoid idle time for the GPU between batches - accumulate_grad_batches: 12 - - # Various other settings, you probably want to leave alone - fast_dev_run: false - limit_train_batches: null - limit_val_batches: null - limit_test_batches: null - limit_predict_batches: null - overfit_batches: 0.0 - val_check_interval: null - check_val_every_n_epoch: 1 - num_sanity_val_steps: 0 - log_every_n_steps: 1 - enable_checkpointing: true - enable_progress_bar: null - enable_model_summary: null - gradient_clip_val: 1.0 - gradient_clip_algorithm: null - deterministic: null - benchmark: null - inference_mode: true - use_distributed_sampler: true - profiler: null - detect_anomaly: false - barebones: false - plugins: null - sync_batchnorm: false - reload_dataloaders_every_n_epochs: 0 - default_root_dir: null - -######################################## -## Training model settings -######################################## -model: - # Model to start the finetune/training process from - load_model: ../model/Echo-A-1B5-Init.pth - - # The model size setting, this MUST match - # your current model settings, refer to the model card - # of the downloaded model for more details - n_embd: 2048 - n_layer: 24 - vocab_size: 50277 - - # Context length to use for the training process - # the larger the number (and batch size) the larger the vram usage - # - # Note that if the datasample context length is larger then the ctx_len - # its training process would be split into ctx_len sized chunks. - # - # This allows the training of extreamly large context length (eg. 100k), - # without eating up too much vram by keeping the training context length - # to a resonable number sutible to the current GPU setup - ctx_len: 128 - - # Data samples would be cut down to the respective max ctx_len_cutoffs - # values if its larger then ctx_len. If the data sample is larger then - # the largest len_cutoff, the remaining data will be discarded - ctx_len_cutoffs: [1024, 2048, 4096, 8192, 16384, 32768, 65536] - # Experimental settings, number of tokens to skip in the data sample - # prefix, for the respective cutoff length. Used to speed up the process - ctx_len_warmup_steps: [0, 0, 0, 0, 0, 0, 0] - - # Learning rate of the training process - # --- - # Initia learning rate of the process - lr_init: 6e-4 - # Final learning rate after the learning rate period - # learning rate will stay at final value from then onwards - # - # NOTE: lr_final / lr_period does not work with warmup_steps - # and will be ignored (or replaced) with the warmup_steps logic instead - lr_final: 4e-4 - # Number of epoch to reduce the learning rate from lr_init to lr_final - # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) - # 0 means lr_final will apply immediately - # -1 means we take the current max_step / max_epoch as the period - lr_period: 1 - # lr_period type if its set, defaults to epoch - lr_period_type: epoch - - # Adam optimizer settings - # You probably want to leave this alone, unless you know what you are doing - beta1: 0.9 - beta2: 0.99 - adam_eps: 1.0e-08 - weight_decay: 0.01 - - # torch.set_float32_matmul_precision, used to optimize operations with tensor cores - # this should be set as null, for non cuda core GPUs - torch_set_float32_matmul_precision: 'high' - # torch_set_float32_matmul_precision: null - - # Segmented based learning, used to work around training of large context length - # beyond what can be supported by the current GPU vram architecture - # - # This is not 1:1 equivalent to the same training process with required vram - # as the training process is split into multiple segments, part by part. - # with limited learnings from the previous segment. - bptt_learning: true - - # Segmented range to performing backprop learning on - # 1 means to apply only for the last segment - # -1 means to apply for all segments - bptt_learning_range: -1 - - # various other settings you probably should leave alone - grad_cp: true - warmup_steps: -1 - layerwise_lr: true - dim_att: null - dim_ffn: null -data: - # dataset_path for the prebuilt dataset, using HF `load_from_disk()` - # - # Use this if you have built your own dataset and saved it with `save_to_disk()` - # with source left as null. Other wise configure this to a directory which the - # dataset will be built and tokenized by the huggingface dataset process. - data_path: ../datapath/enwiki_10k_1024/ - - # Other wise provide the source path, which is used as huggingface dataset path - # this will be used to populate the dataset_path - # - # Use either the following - # - hugging face dataset - # - Directory path to a directory containing dataset files - # - Path to a single dataset file - # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) - # - null - # - # If source is disabled, all other params, except data_path, is ignored - source: "teven/enwiki_10k" - # source: text - # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt - - # Use data_dir, if you are using source=text/json/etc - # this should be relative to the data_path - source_data_dir: null - - # After loading the dataset, split out test data used for validation, - # This process is skipped if the dataset includes a test split - # This process is skipped if set to zero - test_split: 0.01 - test_split_shuffle: false - - # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer - # If using a custom tokenizer, provide the tokenizer file path - # --- - tokenizer: neox - - # Minimum / Maximum token size of the dataset to use - # useful for filtering out small noisy data samples from large datasets - # (eg. removal of small articles of less then 512 tokens from wikipedia) - # - # This is ignored, if set to -1 - min_token_size: 64 - max_token_size: -1 - - # Rechunking of text dataset, this is done only when source is set as 'text' - # and will merge the various sentencees, into larger chunks up to the target size - # - # Defaults to 4096 - # - # This is ignored, if source is not set as text - # This is ignored, if set to zero - # --- - text_rechunk_size: 1024 - - # Apply text rechunk to the dataset, even if its not a 'text' source - # This is done only after dataset filtering, and if source is not 'text' - # --- - text_rechunk_force: true - - # Custom text column to use, useful for dataset with alternative training columns labels - # This is checked before multi column merging, default is null (disabled) - # eg: 'code' - # --- - # custom_text_key: 'code' - - # Multi Column merging process, default setting is used to support and merge - # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] - # - # A minimum of 2 columns is required, with non empty data, for the merge to occur - # If no match is found, this will fallback to the default prompt/completion or text column, - # or throw an error if the default fallback is not found - # --- - # multi_column_keys: ['instruction', 'input', 'output'] - # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] - # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' - - # If processing prompt/completion jsonl pairs, the prompt is masked by default - # use this flag to disable this default behaviour - # --- - # disable_prompt_mask: false - -# Path to the current checkpoint to continue training from -# Enable this to the last checkpoint after the first run -# (if it crash and you want to resume) -# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-dryrun/epoch=0-step=20.ckpt -ckpt_path: null diff --git a/notebook/trainer-validation/infctx-validation.ipynb b/notebook/trainer-validation/infctx-validation.ipynb deleted file mode 100644 index d036f440..00000000 --- a/notebook/trainer-validation/infctx-validation.ipynb +++ /dev/null @@ -1,837 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# InfCtx trainer validation\n", - "This model being trained has the same settings as raven 1B5 model.\n", - "- Layer count: 24\n", - "- Embed size: 2048\n", - "\n", - "The goal is to validate loss rate change, across the exact same hyper parameters with the following\n", - "- 1024 data chunk size\n", - "- same learningrate / weightdecay / seed\n", - "- \"teven/enwiki_10k\" dataset, chunked to 1024 token sizes\n", - "\n", - "With only the change in training context size\n", - "- 1024 context vs 128 context\n", - "\n", - "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps\n", - ">\n", - "> All training runs (except dryrun) is configured to log to weights and bias, comment out the logger in the config file if you want to avoid this\n", - ">\n", - "> Due to existing \"hang\" issues with multi-gpu with bptt_length > 1, segmented training is limited to 1 gpu" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Preparing the init model and test dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# First lets setup the various directories, and get the blank init model, these init model was generated\n", - "# using the original RWKV-LM repo (as at this point of writing, this repo cannot init a model)\n", - "# As such I have preinitialized these blank models and uploaded them to HF for convinence\n", - "!mkdir -p ../../model/\n", - "!mkdir -p ../../datapath/\n", - "!mkdir -p ../../checkpoint/\n", - "!rm -rf ../../model/Echo-A-1B5-Init.pth\n", - "!cd ../../model/ && wget https://huggingface.co/picocreator/memory-size-experiment-for-rwkv/resolve/main/Echo-A-1B5-Init.pth\n", - "!ls -alh ../../model/Echo-A-1B5-Init.pth" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 986.66it/s]\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", - " \r" - ] - } - ], - "source": [ - "# Lets preload the requried dataset\n", - "!cd ../../RWKV-v4neo && python3 preload_dataset.py ../notebook/trainer-validation/infctx-validation-dryrun.yaml" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Trainer Code validation via dryrun\n", - "\n", - "The following dryrun, helps check that the existing trainer code changes are valid across 2 * 2 data samples.\n", - "It does not log the run the W&B" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2023-07-02 17:14:33,790] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", - "Global seed set to 3941088705\n", - "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", - "Detected CUDA files, patching ldflags\n", - "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/wkv_128_bf16/build.ninja...\n", - "Building extension module wkv_128_bf16...\n", - "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "ninja: no work to do.\n", - "Loading extension module wkv_128_bf16...\n", - "Preloading dataset in the current thread\n", - "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 723.90it/s]\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-e4cc6a1335c36775_*_of_00016.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-37a2fa7498f01de6.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-120b4276954261d5_*_of_00016.arrow\n", - "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", - " rank_zero_warn(\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: UserWarning: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n", - " warning_cache.warn(\n", - "[rank: 0] Global seed set to 3941088705\n", - "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "[2023-07-02 17:14:45,934] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", - "Enabling DeepSpeed BF16.\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\u001b[93m [WARNING] \u001b[0m cpu_adam cuda is missing or is incompatible with installed torch, only cpu ops can be compiled!\n", - "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", - "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/cpu_adam/build.ninja...\n", - "Building extension module cpu_adam...\n", - "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "ninja: no work to do.\n", - "Loading extension module cpu_adam...\n", - "Time to load cpu_adam op: 2.321737766265869 seconds\n", - "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", - "\n", - " | Name | Type | Params\n", - "--------------------------------------\n", - "0 | emb | Embedding | 102 M \n", - "1 | blocks | ModuleList | 1.3 B \n", - "2 | ln_out | LayerNorm | 4.1 K \n", - "3 | head | Linear | 102 M \n", - "--------------------------------------\n", - "1.5 B Trainable params\n", - "0 Non-trainable params\n", - "1.5 B Total params\n", - "6,060.425 Total estimated model params size (MB)\n", - "Epoch 0: 0%| | 4/5318 [00:21<7:54:47, 5.36s/it, v_num=1, train/loss=9.810]`Trainer.fit` stopped: `max_steps=2` reached.\n", - "Epoch 0: 0%| | 4/5318 [00:21<7:54:48, 5.36s/it, v_num=1, train/loss=9.810]\n" - ] - } - ], - "source": [ - "# Validate source code and env is working, by doing a short 2 sample dryrun\n", - "!cd ../../RWKV-v4neo && python3 new_train.py fit -c ../notebook/trainer-validation/infctx-validation-dryrun.yaml" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Baseline full context (1024) training\n", - "\n", - "Perform a full 1 epoch training run of training context size = 1024. Ensuring all data samples fit within the allocated training size." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2023-07-01 20:53:18,310] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", - "Global seed set to 3941088705\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mpicocreator\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.4\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230701_205320-k8flu72z\u001b[0m\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-validation-full (train-ctx=1024, data-ctx=1024, bs=12)\u001b[0m\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation\u001b[0m\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/k8flu72z\u001b[0m\n", - "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", - "Detected CUDA files, patching ldflags\n", - "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/wkv_1024_bf16/build.ninja...\n", - "Building extension module wkv_1024_bf16...\n", - "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "ninja: no work to do.\n", - "Loading extension module wkv_1024_bf16...\n", - "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 675.41it/s]\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", - "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", - " rank_zero_warn(\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "[rank: 0] Global seed set to 3941088705\n", - "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "[2023-07-01 20:53:34,204] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", - "Enabling DeepSpeed BF16.\n", - "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/pytorch/callbacks/model_checkpoint.py:615: UserWarning: Checkpoint directory /home/picocreator/rwkv-proj/infctx-dev/checkpoint/trainer-validaiton/infctx-validation-full exists and is not empty.\n", - " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\u001b[93m [WARNING] \u001b[0m cpu_adam cuda is missing or is incompatible with installed torch, only cpu ops can be compiled!\n", - "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", - "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/cpu_adam/build.ninja...\n", - "Building extension module cpu_adam...\n", - "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "ninja: no work to do.\n", - "Loading extension module cpu_adam...\n", - "Time to load cpu_adam op: 2.312431812286377 seconds\n", - "Loading `train_dataloader` to estimate number of stepping batches.\n", - "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", - "\n", - " | Name | Type | Params\n", - "--------------------------------------\n", - "0 | emb | Embedding | 102 M \n", - "1 | blocks | ModuleList | 1.3 B \n", - "2 | ln_out | LayerNorm | 4.1 K \n", - "3 | head | Linear | 102 M \n", - "--------------------------------------\n", - "1.5 B Trainable params\n", - "0 Non-trainable params\n", - "1.5 B Total params\n", - "6,060.425 Total estimated model params size (MB)\n", - "Epoch 0: 100%|█| 5318/5318 [51:02<00:00, 1.74it/s, v_num=u72z, train/loss=5.940\n", - "Validation: 0it [00:00, ?it/s]\u001b[A\n", - "Validation: 0%| | 0/54 [00:00 PS: Weights and biases logging is enabled" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2023-07-02 11:57:01,839] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", - "Global seed set to 3941088705\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mpicocreator\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.4\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230702_115703-g3mffwuh\u001b[0m\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-validation-first-segment (train-ctx=128, data-ctx=1024, bs=12)\u001b[0m\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation\u001b[0m\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/g3mffwuh\u001b[0m\n", - "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", - "Detected CUDA files, patching ldflags\n", - "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/wkv_128_bf16/build.ninja...\n", - "Building extension module wkv_128_bf16...\n", - "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "ninja: no work to do.\n", - "Loading extension module wkv_128_bf16...\n", - "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 542.25it/s]\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", - "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", - " rank_zero_warn(\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "[rank: 0] Global seed set to 3941088705\n", - "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "[2023-07-02 11:57:17,865] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", - "Enabling DeepSpeed BF16.\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\u001b[93m [WARNING] \u001b[0m cpu_adam cuda is missing or is incompatible with installed torch, only cpu ops can be compiled!\n", - "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", - "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/cpu_adam/build.ninja...\n", - "Building extension module cpu_adam...\n", - "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", - "ninja: no work to do.\n", - "Loading extension module cpu_adam...\n", - "Time to load cpu_adam op: 2.3168303966522217 seconds\n", - "Loading `train_dataloader` to estimate number of stepping batches.\n", - "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", - "\n", - " | Name | Type | Params\n", - "--------------------------------------\n", - "0 | emb | Embedding | 102 M \n", - "1 | blocks | ModuleList | 1.3 B \n", - "2 | ln_out | LayerNorm | 4.1 K \n", - "3 | head | Linear | 102 M \n", - "--------------------------------------\n", - "1.5 B Trainable params\n", - "0 Non-trainable params\n", - "1.5 B Total params\n", - "6,060.425 Total estimated model params size (MB)\n", - "Epoch 0: 100%|█| 5318/5318 [2:08:13<00:00, 1.45s/it, v_num=fwuh, train/loss=6.8\n", - "Validation: 0it [00:00, ?it/s]\u001b[A\n", - "Validation: 0%| | 0/54 [00:00 Date: Sat, 8 Jul 2023 08:08:32 +0000 Subject: [PATCH 36/57] matmul-precision notebook cleanup --- .../trainer-validation/matmul-precision.ipynb | 72 ++++--------------- 1 file changed, 14 insertions(+), 58 deletions(-) diff --git a/notebook/trainer-validation/matmul-precision.ipynb b/notebook/trainer-validation/matmul-precision.ipynb index ea23420c..1c931249 100644 --- a/notebook/trainer-validation/matmul-precision.ipynb +++ b/notebook/trainer-validation/matmul-precision.ipynb @@ -12,7 +12,9 @@ "\n", "The goal is to validate that lower matmul accuracy has now negative impact on loss training\n", "\n", - "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps" + "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps\n", + ">\n", + "> And that you have completed the `baseline-setup.ipynb`" ] }, { @@ -20,61 +22,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Preparing the init model and test dataset" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# First lets setup the various directories, and get the blank init model, these init model was generated\n", - "# using the original RWKV-LM repo (as at this point of writing, this repo cannot init a model)\n", - "# As such I have preinitialized these blank models and uploaded them to HF for convinence\n", - "!mkdir -p ../../model/\n", - "!mkdir -p ../../datapath/\n", - "!mkdir -p ../../checkpoint/\n", - "!rm -rf ../../model/Echo-A-1B5-Init.pth\n", - "!cd ../../model/ && wget https://huggingface.co/picocreator/memory-size-experiment-for-rwkv/resolve/main/Echo-A-1B5-Init.pth\n", - "!ls -alh ../../model/Echo-A-1B5-Init.pth" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 986.66it/s]\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", - " \r" - ] - } - ], - "source": [ - "# Lets preload the requried dataset\n", - "!cd ../../RWKV-v4neo && python3 preload_dataset.py ../notebook/trainer-validation/infctx-validation-dryrun.yaml" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Baseline full context (1024) training\n", + "# (optional) Baseline full context (1024) training\n", "\n", - "Perform a full 1 epoch training run of training context size = 1024. Ensuring all data samples fit within the allocated training size.\n", + "(you can skip this, and use the optional baseline found in `baseline-setup.ipynb`)\n", "\n", - "(this is the same baseline as infctx-validation)\n", - "\n", - "> PS: Weights and biases logging is enabled" + "Perform a full 1 epoch training run of training context size = 1024. Ensuring all data samples fit within the allocated training size." ] }, { @@ -229,8 +181,9 @@ } ], "source": [ - "# Full training run\n", - "!cd ../../RWKV-v4neo && python3 new_train.py fit -c ../notebook/trainer-validation/infctx-validation-full.yaml" + "!cd ../../RWKV-v4neo && \\\n", + " python3 new_train.py fit \\\n", + " -c ../notebook/trainer-validation/config/baseline-1024.yaml" ] }, { @@ -396,8 +349,11 @@ } ], "source": [ - "# Full training run\n", - "!cd ../../RWKV-v4neo && python3 new_train.py fit -c ../notebook/trainer-validation/matmul-medium-precision.yaml" + "!cd ../../RWKV-v4neo && \\\n", + " python3 new_train.py fit \\\n", + " -c ../notebook/trainer-validation/config/baseline-1024.yaml\n", + " --trainer.logger.init_args.name=\"infctx-validation-baseline (matmul_precision='medium', train-ctx=1024, data-ctx=1024, bs=10)\" \\\n", + " --model.torch_set_float32_matmul_precision=\"medium\"" ] } ], From 358e102c7afd96eadbb4eae6e78b71698e54467d Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 09:30:06 +0000 Subject: [PATCH 37/57] torch compile bechmark v1 --- .../torch-compile-perf.ipynb | 174 ++++++++++++++---- 1 file changed, 143 insertions(+), 31 deletions(-) diff --git a/notebook/trainer-validation/torch-compile-perf.ipynb b/notebook/trainer-validation/torch-compile-perf.ipynb index bfa69d71..246fd02f 100644 --- a/notebook/trainer-validation/torch-compile-perf.ipynb +++ b/notebook/trainer-validation/torch-compile-perf.ipynb @@ -3431,17 +3431,22 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 76, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "First step figures ...\n", + "Baseline: {'it': 1, 'time': 10, 's_time': '00:10', 'loss': 10.9}\n", + "JIT: {'it': 1, 'time': 12, 's_time': '00:12', 'loss': 10.9}\n", + "Torch Compile: {'it': 1, 'time': 80, 's_time': '01:20', 'loss': 10.9}\n", + "\n", "Last step figures ...\n", - "Baseline: {'it': 1000, 'time': 461, 's_time': '07:41', 'loss': 6.62}\n", - "JIT: {'it': 1000, 'time': 443, 's_time': '07:23', 'loss': 6.66}\n", - "Torch Compile: {'it': 1000, 'time': 451, 's_time': '07:31', 'loss': 6.69}\n" + "Baseline: {'it': 1000, 'time': 1466, 's_time': '24:26', 'loss': 6.62}\n", + "JIT: {'it': 1000, 'time': 1408, 's_time': '23:28', 'loss': 6.66}\n", + "Torch Compile: {'it': 1000, 'time': 1433, 's_time': '23:53', 'loss': 6.69}\n" ] } ], @@ -3460,7 +3465,7 @@ " # Check if the line starts with \"Epoch 0:\"\n", " if line.startswith(\"Epoch 0:\"):\n", " iteration = re.search(r'(?<=\\| )(\\d+)', line) # Extracts the iteration number\n", - " time_spent = re.search(r'(?<=\\[\\d\\d:\\d\\d<)(.*?)(?=\\,)', line) # Extracts the time spent so far\n", + " time_spent = re.search(r'(?<=\\[)(.*?)(?=<)', line) # Extracts the time spent so far\n", " loss = re.search(r'(?<=train/loss=)(\\d+.\\d+)', line) # Extracts the train/loss number\n", " \n", " if iteration and time_spent and loss:\n", @@ -3478,11 +3483,16 @@ "step_jit = extract_from_training_logs(\"./logs/torch-compile-perf_jit.log\")\n", "step_tcompile = extract_from_training_logs(\"./logs/torch-compile-perf_torch-compile.log\")\n", "\n", - "# Print the high level numbers\n", + "# Print the high level numbers (quick debugging, if log has issues)\n", + "print(\"First step figures ...\")\n", + "print(\"Baseline: \", step_baseline[0])\n", + "print(\"JIT: \", step_jit[0])\n", + "print(\"Torch Compile: \", step_tcompile[0])\n", + "print(\"\")\n", "print(\"Last step figures ...\")\n", "print(\"Baseline: \", step_baseline[-1])\n", "print(\"JIT: \", step_jit[-1])\n", - "print(\"Torch Compile: \", step_tcompile[-1])" + "print(\"Torch Compile: \", step_tcompile[-1])\n" ] }, { @@ -3548,34 +3558,12 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 67, "metadata": {}, "outputs": [ - { - "ename": "ValueError", - "evalue": "'--.' is not a valid value for ls; supported values are '-', '--', '-.', ':', 'None', ' ', '', 'solid', 'dashed', 'dashdot', 'dotted'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[66], line 14\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[39m# Plot deltas\u001b[39;00m\n\u001b[1;32m 13\u001b[0m plt\u001b[39m.\u001b[39mplot(it_jit, delta_jit_baseline, label\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mJIT - Baseline\u001b[39m\u001b[39m\"\u001b[39m, linestyle\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39m-\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m---> 14\u001b[0m plt\u001b[39m.\u001b[39;49mplot(it_tcompile, delta_tcompile_baseline, label\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mTCompile - Baseline\u001b[39;49m\u001b[39m\"\u001b[39;49m, linestyle\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39m--.\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[1;32m 16\u001b[0m plt\u001b[39m.\u001b[39mxlabel(\u001b[39m'\u001b[39m\u001b[39mIteration step\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 17\u001b[0m plt\u001b[39m.\u001b[39mylabel(\u001b[39m'\u001b[39m\u001b[39mDelta Loss\u001b[39m\u001b[39m'\u001b[39m)\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/pyplot.py:2812\u001b[0m, in \u001b[0;36mplot\u001b[0;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2810\u001b[0m \u001b[39m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[39m.\u001b[39mplot)\n\u001b[1;32m 2811\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mplot\u001b[39m(\u001b[39m*\u001b[39margs, scalex\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, scaley\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m-> 2812\u001b[0m \u001b[39mreturn\u001b[39;00m gca()\u001b[39m.\u001b[39;49mplot(\n\u001b[1;32m 2813\u001b[0m \u001b[39m*\u001b[39;49margs, scalex\u001b[39m=\u001b[39;49mscalex, scaley\u001b[39m=\u001b[39;49mscaley,\n\u001b[1;32m 2814\u001b[0m \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49m({\u001b[39m\"\u001b[39;49m\u001b[39mdata\u001b[39;49m\u001b[39m\"\u001b[39;49m: data} \u001b[39mif\u001b[39;49;00m data \u001b[39mis\u001b[39;49;00m \u001b[39mnot\u001b[39;49;00m \u001b[39mNone\u001b[39;49;00m \u001b[39melse\u001b[39;49;00m {}), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_axes.py:1688\u001b[0m, in \u001b[0;36mAxes.plot\u001b[0;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1445\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1446\u001b[0m \u001b[39mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[1;32m 1447\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1685\u001b[0m \u001b[39m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[1;32m 1686\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1687\u001b[0m kwargs \u001b[39m=\u001b[39m cbook\u001b[39m.\u001b[39mnormalize_kwargs(kwargs, mlines\u001b[39m.\u001b[39mLine2D)\n\u001b[0;32m-> 1688\u001b[0m lines \u001b[39m=\u001b[39m [\u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_lines(\u001b[39m*\u001b[39margs, data\u001b[39m=\u001b[39mdata, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)]\n\u001b[1;32m 1689\u001b[0m \u001b[39mfor\u001b[39;00m line \u001b[39min\u001b[39;00m lines:\n\u001b[1;32m 1690\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39madd_line(line)\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:311\u001b[0m, in \u001b[0;36m_process_plot_var_args.__call__\u001b[0;34m(self, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m this \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m args[\u001b[39m0\u001b[39m],\n\u001b[1;32m 310\u001b[0m args \u001b[39m=\u001b[39m args[\u001b[39m1\u001b[39m:]\n\u001b[0;32m--> 311\u001b[0m \u001b[39myield from\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_plot_args(\n\u001b[1;32m 312\u001b[0m this, kwargs, ambiguous_fmt_datakey\u001b[39m=\u001b[39;49mambiguous_fmt_datakey)\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:544\u001b[0m, in \u001b[0;36m_process_plot_var_args._plot_args\u001b[0;34m(self, tup, kwargs, return_kwargs, ambiguous_fmt_datakey)\u001b[0m\n\u001b[1;32m 542\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mlist\u001b[39m(result)\n\u001b[1;32m 543\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 544\u001b[0m \u001b[39mreturn\u001b[39;00m [l[\u001b[39m0\u001b[39;49m] \u001b[39mfor\u001b[39;49;00m l \u001b[39min\u001b[39;49;00m result]\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:544\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 542\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mlist\u001b[39m(result)\n\u001b[1;32m 543\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 544\u001b[0m \u001b[39mreturn\u001b[39;00m [l[\u001b[39m0\u001b[39m] \u001b[39mfor\u001b[39;00m l \u001b[39min\u001b[39;00m result]\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:537\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 535\u001b[0m labels \u001b[39m=\u001b[39m [label] \u001b[39m*\u001b[39m n_datasets\n\u001b[0;32m--> 537\u001b[0m result \u001b[39m=\u001b[39m (make_artist(x[:, j \u001b[39m%\u001b[39;49m ncx], y[:, j \u001b[39m%\u001b[39;49m ncy], kw,\n\u001b[1;32m 538\u001b[0m {\u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs, \u001b[39m'\u001b[39;49m\u001b[39mlabel\u001b[39;49m\u001b[39m'\u001b[39;49m: label})\n\u001b[1;32m 539\u001b[0m \u001b[39mfor\u001b[39;00m j, label \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(labels))\n\u001b[1;32m 541\u001b[0m \u001b[39mif\u001b[39;00m return_kwargs:\n\u001b[1;32m 542\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mlist\u001b[39m(result)\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/axes/_base.py:351\u001b[0m, in \u001b[0;36m_process_plot_var_args._makeline\u001b[0;34m(self, x, y, kw, kwargs)\u001b[0m\n\u001b[1;32m 349\u001b[0m default_dict \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_getdefaults(\u001b[39mset\u001b[39m(), kw)\n\u001b[1;32m 350\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_setdefaults(default_dict, kw)\n\u001b[0;32m--> 351\u001b[0m seg \u001b[39m=\u001b[39m mlines\u001b[39m.\u001b[39;49mLine2D(x, y, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkw)\n\u001b[1;32m 352\u001b[0m \u001b[39mreturn\u001b[39;00m seg, kw\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/_api/deprecation.py:454\u001b[0m, in \u001b[0;36mmake_keyword_only..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 448\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(args) \u001b[39m>\u001b[39m name_idx:\n\u001b[1;32m 449\u001b[0m warn_deprecated(\n\u001b[1;32m 450\u001b[0m since, message\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mPassing the \u001b[39m\u001b[39m%(name)s\u001b[39;00m\u001b[39m \u001b[39m\u001b[39m%(obj_type)s\u001b[39;00m\u001b[39m \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 451\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mpositionally is deprecated since Matplotlib \u001b[39m\u001b[39m%(since)s\u001b[39;00m\u001b[39m; the \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 452\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mparameter will become keyword-only \u001b[39m\u001b[39m%(removal)s\u001b[39;00m\u001b[39m.\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 453\u001b[0m name\u001b[39m=\u001b[39mname, obj_type\u001b[39m=\u001b[39m\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mparameter of \u001b[39m\u001b[39m{\u001b[39;00mfunc\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m()\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m--> 454\u001b[0m \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/lines.py:360\u001b[0m, in \u001b[0;36mLine2D.__init__\u001b[0;34m(self, xdata, ydata, linewidth, linestyle, color, gapcolor, marker, markersize, markeredgewidth, markeredgecolor, markerfacecolor, markerfacecoloralt, fillstyle, antialiased, dash_capstyle, solid_capstyle, dash_joinstyle, solid_joinstyle, pickradius, drawstyle, markevery, **kwargs)\u001b[0m\n\u001b[1;32m 357\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_dash_pattern \u001b[39m=\u001b[39m (\u001b[39m0\u001b[39m, \u001b[39mNone\u001b[39;00m) \u001b[39m# offset, dash (scaled by linewidth)\u001b[39;00m\n\u001b[1;32m 359\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mset_linewidth(linewidth)\n\u001b[0;32m--> 360\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mset_linestyle(linestyle)\n\u001b[1;32m 361\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mset_drawstyle(drawstyle)\n\u001b[1;32m 363\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_color \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/lines.py:1170\u001b[0m, in \u001b[0;36mLine2D.set_linestyle\u001b[0;34m(self, ls)\u001b[0m\n\u001b[1;32m 1168\u001b[0m \u001b[39mif\u001b[39;00m ls \u001b[39min\u001b[39;00m [\u001b[39m'\u001b[39m\u001b[39m \u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mnone\u001b[39m\u001b[39m'\u001b[39m]:\n\u001b[1;32m 1169\u001b[0m ls \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mNone\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m-> 1170\u001b[0m _api\u001b[39m.\u001b[39;49mcheck_in_list([\u001b[39m*\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_lineStyles, \u001b[39m*\u001b[39;49mls_mapper_r], ls\u001b[39m=\u001b[39;49mls)\n\u001b[1;32m 1171\u001b[0m \u001b[39mif\u001b[39;00m ls \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lineStyles:\n\u001b[1;32m 1172\u001b[0m ls \u001b[39m=\u001b[39m ls_mapper_r[ls]\n", - "File \u001b[0;32m~/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/matplotlib/_api/__init__.py:131\u001b[0m, in \u001b[0;36mcheck_in_list\u001b[0;34m(_values, _print_supported_values, **kwargs)\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[39mif\u001b[39;00m _print_supported_values:\n\u001b[1;32m 130\u001b[0m msg \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m; supported values are \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m, \u001b[39m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mjoin(\u001b[39mmap\u001b[39m(\u001b[39mrepr\u001b[39m,\u001b[39m \u001b[39mvalues))\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[0;32m--> 131\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(msg)\n", - "\u001b[0;31mValueError\u001b[0m: '--.' is not a valid value for ls; supported values are '-', '--', '-.', ':', 'None', ' ', '', 'solid', 'dashed', 'dashdot', 'dotted'" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3607,6 +3595,130 @@ "plt.grid(True)\n", "plt.show()" ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working as per designed, the differences between \"Delta Loss\" should be within margin of error, of run-by-run varience" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot the time charts!\n", + "\n", + "Lets start with a basic iteration step over cummulative time" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Extract the 'it' and 'time' values from each dictionary in each list\n", + "it_baseline = [x['it'] for x in step_baseline]\n", + "time_baseline = [x['time'] for x in step_baseline]\n", + "\n", + "it_jit = [x['it'] for x in step_jit]\n", + "time_jit = [x['time'] for x in step_jit]\n", + "\n", + "it_tcompile = [x['it'] for x in step_tcompile]\n", + "time_tcompile = [x['time'] for x in step_tcompile]\n", + "\n", + "# Plot cumulative time for each iteration\n", + "plt.plot(it_baseline, time_baseline, label='Baseline')\n", + "plt.plot(it_jit, time_jit, label='Jit')\n", + "plt.plot(it_tcompile, time_tcompile, label='TCompile')\n", + "\n", + "# Label the axes\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Cumulative Time')\n", + "\n", + "# Add a legend\n", + "plt.legend(loc='upper left')\n", + "\n", + "# Display the plot\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working correctly it should show that\n", + "\n", + "- baseline: lowest starting time, highest accumulative rate\n", + "- JIT: similar starting time, lower accumulative rate\n", + "- TCompile: slowest starting time, lowest accumulative rate\n", + "\n", + "This can be observed by getting the average time per iteration for the first 200 steps and the last 800 steps" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average delta time for the first 200 iterations:\n", + "Baseline: 830.0 ms\n", + "Jit: 800.0 ms\n", + "TCompile: 775.0 ms\n", + "\n", + "Average delta time after 'warmup':\n", + "Baseline: 716.2687395891172 ms\n", + "Jit: 686.2853970016657 ms\n", + "TCompile: 665.1860077734592 ms\n" + ] + } + ], + "source": [ + "# Compute the average time for the first `n` iterations and for the rest\n", + "def compute_average_delta(data, n):\n", + " time = [x['time'] for x in data]\n", + " avg_first_n = (time[n-1] - time[0]) / n if n > 0 else 0\n", + " avg_remaining = (time[-1] - time[n]) / (len(time)-n) if (len(time)-n) != 0 else 0\n", + " return avg_first_n, avg_remaining\n", + "\n", + "n = 200\n", + "avg_delta_baseline = compute_average_delta(step_baseline, n)\n", + "avg_delta_jit = compute_average_delta(step_jit, n)\n", + "avg_delta_tcompile = compute_average_delta(step_tcompile, n)\n", + "\n", + "print(\"Average delta time for the first 200 iterations ('warmup'):\")\n", + "print(f\"Baseline: {avg_delta_baseline[0] * 1000} ms\")\n", + "print(f\"Jit: {avg_delta_jit[0] * 1000} ms\")\n", + "print(f\"TCompile: {avg_delta_tcompile[0] * 1000} ms\")\n", + "print(\"\")\n", + "\n", + "print(\"Average delta time after 'warmup':\")\n", + "print(f\"Baseline: {avg_delta_baseline[1] * 1000} ms\")\n", + "print(f\"Jit: {avg_delta_jit[1] * 1000} ms\")\n", + "print(f\"TCompile: {avg_delta_tcompile[1] * 1000} ms\")\n", + "\n" + ] } ], "metadata": { From 6cba59fed49b26fb91e022a835ff7cf40b09515a Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 10:18:58 +0000 Subject: [PATCH 38/57] btter perf, without eager torch.compile --- .../torch-compile-perf.ipynb | 1251 ++++------------- 1 file changed, 238 insertions(+), 1013 deletions(-) diff --git a/notebook/trainer-validation/torch-compile-perf.ipynb b/notebook/trainer-validation/torch-compile-perf.ipynb index 246fd02f..79c3fe22 100644 --- a/notebook/trainer-validation/torch-compile-perf.ipynb +++ b/notebook/trainer-validation/torch-compile-perf.ipynb @@ -2311,14 +2311,14 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 85, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[2023-07-08 06:36:18,883] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[2023-07-08 09:31:15,877] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", "[RWKV.model] Running RWKV model via the following optimization mode : torch-compile\n", "Global seed set to 3941088705\n", "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", @@ -2335,14 +2335,14 @@ "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 913.39it/s]\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 971.35it/s]\n", "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-a9b10ddaafcd70a8_*_of_00032.arrow\n", "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-cfd32fc41583b797_*_of_00032.arrow\n", "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f22a54fa61543287_*_of_00032.arrow\n", "[rank: 0] Global seed set to 3941088705 \n", "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "[2023-07-08 06:36:32,475] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", - "[2023-07-08 06:36:32,476] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "[2023-07-08 09:31:29,380] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-08 09:31:29,381] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", "Enabling DeepSpeed BF16.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096)\n", @@ -2353,7 +2353,7 @@ "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", "ninja: no work to do.\n", "Loading extension module cpu_adam...\n", - "Time to load cpu_adam op: 2.3331191539764404 seconds\n", + "Time to load cpu_adam op: 2.3348143100738525 seconds\n", "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", "\n", " | Name | Type | Params\n", @@ -2367,1013 +2367,238 @@ "0 Non-trainable params\n", "1.5 B Total params\n", "6,060.425 Total estimated model params size (MB)\n", - "Epoch 0: 0%| | 0/1315 [00:00 Date: Sat, 8 Jul 2023 10:19:06 +0000 Subject: [PATCH 39/57] perf log --- .../logs/torch-compile-perf_torch-compile.log | 2008 ++++++++--------- 1 file changed, 1004 insertions(+), 1004 deletions(-) diff --git a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log index 4bf7e758..ad6325c4 100644 --- a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log +++ b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log @@ -1,1010 +1,1010 @@ -[2023-07-08 06:36:18,883] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) +[2023-07-08 09:31:15,877] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) [RWKV.model] Running RWKV model via the following optimization mode : torch-compile ninja: no work to do. -[2023-07-08 06:36:32,475] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented -[2023-07-08 06:36:32,476] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. +[2023-07-08 09:31:29,380] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented +[2023-07-08 09:31:29,381] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. [WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096) ninja: no work to do. -Time to load cpu_adam op: 2.3331191539764404 seconds +Time to load cpu_adam op: 2.3348143100738525 seconds Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] Training: 0it [00:00, ?it/s] Training: 0%| | 0/1315 [00:00 Date: Sat, 8 Jul 2023 13:45:17 +0000 Subject: [PATCH 40/57] more experiments in torch.compile settings --- RWKV-v4neo/src/model.py | 90 +- .../trainer-validation/bptt-validation.ipynb | 653 +++++- .../logs/torch-compile-perf_torch-compile.log | 2008 ++++++++--------- .../torch-compile-perf.ipynb | 1324 ++++++++--- 4 files changed, 2680 insertions(+), 1395 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 7fcc311f..a17b140d 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -61,9 +61,14 @@ def is_torch_version_above(required_version): # without any graph breaks - providing the highest level of optimization via torch.compile TCompileMax = lambda x: torch.compile(x, fullgraph=True) - # Baseline, and eager mode are for torch comile operations, that can be partially optimized - TCompileBaseline = lambda x: torch.compile(x, fullgraph=False) - TCompileEager = lambda x: torch.compile(x, fullgraph=False, backend="eager") + # # Baseline, and eager mode are for torch comile operations, that can be partially optimized + # TCompileBaseline = lambda x: torch.compile(x, fullgraph=False) + # TCompileEager = lambda x: torch.compile(x, fullgraph=False, backend="eager") + + # We use native lambda, for baseline / eager compile, as current benchmark shows that + # it is generally faster to leave them as native python functions instead + # (this may change in the future as torch.compile improves) + TCompileBaseline = lambda x: x # Used to wrap functions which are **not** torch.compile compatible TCompileDisable = torch._dynamo.disable @@ -81,7 +86,6 @@ def is_torch_version_above(required_version): TCompileMax = lambda x: x TCompileBaseline = lambda x: x - TCompileEager = lambda x: x TCompileDisable = lambda x: x else: RWKV_TORCH_RUN_MODE = "torch-native" @@ -91,7 +95,6 @@ def is_torch_version_above(required_version): TCompileMax = lambda x: x TCompileBaseline = lambda x: x - TCompileEager = lambda x: x TCompileDisable = lambda x: x print(f"[RWKV.model] Running RWKV model via the following optimization mode : {RWKV_TORCH_RUN_MODE}") @@ -275,10 +278,9 @@ def forward(self, x, last_state: ChannelMixState): ######################################################################################################## -# The RWKV Model with our blocks +# The RWKV Model blocks ######################################################################################################## - class Block(nn.Module): def __init__(self, layer_id, n_layer, n_embd, dim_att, dim_ffn): @@ -314,6 +316,15 @@ class L2Wrap(torch.autograd.Function): @staticmethod def forward(ctx, loss, y, token_amount, currentMask): + # Currently (8th July 2023), save_for_backward, causes an issue with + # pytorch.compile (see: https://github.com/pytorch/pytorch/blob/e600505e3209eaf539e8bc99870ea55236cefbf5/torch/_dynamo/variables/higher_order_ops.py#L735) + # + # Due to L2Wrap being a major hotspot, we should monitor this status + # so that once its resolved, we can include the L2Wrap step in the torch.compile path + # + # See also: + # - checkpointed_step + # - _RWKV_checkpointed_step_optimized ctx.save_for_backward(y) ctx.token_amount = token_amount ctx.currentMask = currentMask @@ -331,7 +342,27 @@ def backward(ctx, grad_output): gy = gy * ctx.currentMask[:, None][None, :] return (grad_output, gy, None, None) +######################################################################################################## +# Static optimized functions +######################################################################################################## + +# @ TCompileMax +# def _RWKV_checkpointed_step_optimized( +# logits, new_shift_states, new_wkv_states, +# idx, targets, mask, prev_loss, last_shift_states, last_wkv_states, prev_steps, +# total_mask_sum +# ): +# loss = F.cross_entropy(logits.view(-1, logits.size(-1)), +# targets.view(-1), +# reduction="none") +# submask = mask.view(-1)[:loss.shape[0]] +# submask_sum = torch.sum(submask) +# loss = torch.sum(loss * submask) / total_mask_sum +# return loss, submask, submask_sum +######################################################################################################## +# Core RWKV module +######################################################################################################## class RWKV(L.LightningModule): def __init__(self, @@ -618,9 +649,17 @@ def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, new_states = BlockStateList.empty(self.n_layer, B, self.n_embd, x.device, x.dtype) - for i, (block, last_state) in enumerate( - zip(self.blocks, - BlockStateList(last_shift_states, last_wkv_states))): + # Avoid using the zip operation, as torch.compile throws an exception on it + # with `zip not reconized as a valid function` + # --- + # for i, (block, last_state) in enumerate( + # zip(self.blocks, + # BlockStateList(last_shift_states, last_wkv_states))): + # --- + for i in range(len(self.blocks)): + block = self.blocks[i] + last_state = BlockStateList(last_shift_states, last_wkv_states)[i] + if self.grad_cp: x, new_state = deepspeed_checkpoint( block, x, last_state) @@ -689,8 +728,17 @@ def compute_loss(self, batch, batch_idx, is_training_run: bool): # Perform cutoff for training run if is_training_run: prev_step = 0 - for step, len_cut in zip(self.ctx_len_warmup_steps, - self.ctx_len_cutoffs): + + # Avoid using the zip operation, as torch.compile throws an exception on it + # with `zip not reconized as a valid function` + # --- + # for step, len_cut in zip(self.ctx_len_warmup_steps, + # self.ctx_len_cutoffs): + # --- + for i in range(min(len(self.ctx_len_warmup_steps), len(self.ctx_len_cutoffs))): + step = self.ctx_len_warmup_steps[i] + len_cut = self.ctx_len_cutoffs[i] + if prev_step <= self.global_step < step and len_cut < seq.shape[ 1] - 1: pos = randint(0, seq.shape[1] - len_cut - 1) @@ -716,18 +764,28 @@ def compute_loss(self, batch, batch_idx, is_training_run: bool): # If total_mask_sum, we skip, as there is no tokens of value to learn from anyway if total_mask_sum == 0: return 0 - + def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, last_wkv_states, prev_steps): logits, new_shift_states, new_wkv_states = self( idx, last_shift_states, last_wkv_states) + + # # If torch.compile is enabled, this is a heavily optimized varient + # # (especially on F.cross_entropy) else its just another static function + # loss, submask, submask_sum = _RWKV_checkpointed_step_optimized( + # logits, new_shift_states, new_wkv_states, + # idx, targets, mask, prev_loss, + # last_shift_states, last_wkv_states, prev_steps, + # total_mask_sum + # ) + loss = F.cross_entropy(logits.view(-1, logits.size(-1)), - targets.view(-1), - reduction="none") + targets.view(-1), + reduction="none") submask = mask.view(-1)[:loss.shape[0]] submask_sum = torch.sum(submask) - loss = torch.sum(loss * submask) / total_mask_sum + loss = L2Wrap.apply(loss, logits, total_mask_sum, submask) new_steps = prev_steps + submask_sum new_loss = prev_loss + loss diff --git a/notebook/trainer-validation/bptt-validation.ipynb b/notebook/trainer-validation/bptt-validation.ipynb index c879c7d9..c34686c9 100644 --- a/notebook/trainer-validation/bptt-validation.ipynb +++ b/notebook/trainer-validation/bptt-validation.ipynb @@ -82,55 +82,56 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[2023-07-01 20:53:18,310] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[2023-07-08 09:06:42,637] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[RWKV.model] Running RWKV model via the following optimization mode : torch-compile\n", "Global seed set to 3941088705\n", "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mpicocreator\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.4\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230701_205320-k8flu72z\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.5\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230708_090644-3bz2cq44\u001b[0m\n", "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-validation-full (train-ctx=1024, data-ctx=1024, bs=12)\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-bptt-validation (full, train-ctx=1024, data-ctx=1024)\u001b[0m\n", "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation\u001b[0m\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/k8flu72z\u001b[0m\n", - "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/3bz2cq44\u001b[0m\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", "Detected CUDA files, patching ldflags\n", - "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/wkv_1024_bf16/build.ninja...\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_1024_bf16/build.ninja...\n", "Building extension module wkv_1024_bf16...\n", "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", "ninja: no work to do.\n", "Loading extension module wkv_1024_bf16...\n", - "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 675.41it/s]\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", - "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", " rank_zero_warn(\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", - "[rank: 0] Global seed set to 3941088705\n", + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 858.61it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-85ed41912c749812_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-d919d919e3a12608_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f2a6e7ee57d796c9_*_of_00032.arrow\n", + "[rank: 0] Global seed set to 3941088705 \n", "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", - "[2023-07-01 20:53:34,204] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-08 09:06:59,020] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-08 09:06:59,021] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", "Enabling DeepSpeed BF16.\n", - "/home/picocreator/anaconda3/envs/rwkv-exp/lib/python3.11/site-packages/lightning/pytorch/callbacks/model_checkpoint.py:615: UserWarning: Checkpoint directory /home/picocreator/rwkv-proj/infctx-dev/checkpoint/trainer-validaiton/infctx-validation-full exists and is not empty.\n", - " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\u001b[93m [WARNING] \u001b[0m cpu_adam cuda is missing or is incompatible with installed torch, only cpu ops can be compiled!\n", - "Using /home/picocreator/.cache/torch_extensions/py311_cu117 as PyTorch extensions root...\n", - "Emitting ninja build file /home/picocreator/.cache/torch_extensions/py311_cu117/cpu_adam/build.ninja...\n", + "[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (1024)\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/cpu_adam/build.ninja...\n", "Building extension module cpu_adam...\n", "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", "ninja: no work to do.\n", "Loading extension module cpu_adam...\n", - "Time to load cpu_adam op: 2.312431812286377 seconds\n", + "Time to load cpu_adam op: 2.3396010398864746 seconds\n", "Loading `train_dataloader` to estimate number of stepping batches.\n", "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", "\n", @@ -145,89 +146,525 @@ "0 Non-trainable params\n", "1.5 B Total params\n", "6,060.425 Total estimated model params size (MB)\n", - "Epoch 0: 100%|█| 5318/5318 [51:02<00:00, 1.74it/s, v_num=u72z, train/loss=5.940\n", - "Validation: 0it [00:00, ?it/s]\u001b[A\n", - "Validation: 0%| | 0/54 [00:00' (/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/wandb/sdk/interface/interface.py:572)\n", + "to diagnose recompilation issues, set env variable TORCHDYNAMO_REPORT_GUARD_FAILURES=1 and also see https://pytorch.org/docs/master/compile/troubleshooting.html.\n", + "Epoch 0: 11%| | 610/5308 [12:13<1:34:07, 1.20s/it, v_num=cq44, train/loss=7.50[2023-07-08 09:19:46,835] torch._dynamo.convert_frame: [WARNING] torch._dynamo hit config.cache_size_limit (64)\n", + " function: 'wrapper' (/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:358)\n", + "to diagnose recompilation issues, set env variable TORCHDYNAMO_REPORT_GUARD_FAILURES=1 and also see https://pytorch.org/docs/master/compile/troubleshooting.html.\n", + "[2023-07-08 09:19:46,836] torch._dynamo.convert_frame: [WARNING] torch._dynamo hit config.cache_size_limit (64)\n", + " function: 'wrapper_fn' (/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:337)\n", + "to diagnose recompilation issues, set env variable TORCHDYNAMO_REPORT_GUARD_FAILURES=1 and also see https://pytorch.org/docs/master/compile/troubleshooting.html.\n", + "[2023-07-08 09:19:46,837] torch._dynamo.convert_frame: [WARNING] torch._dynamo hit config.cache_size_limit (64)\n", + " function: '' (/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:313)\n", + "to diagnose recompilation issues, set env variable TORCHDYNAMO_REPORT_GUARD_FAILURES=1 and also see https://pytorch.org/docs/master/compile/troubleshooting.html.\n", + "[2023-07-08 09:19:46,838] torch._dynamo.convert_frame: [WARNING] torch._dynamo hit config.cache_size_limit (64)\n", + " function: 'log' (/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:1550)\n", + "to diagnose recompilation issues, set env variable TORCHDYNAMO_REPORT_GUARD_FAILURES=1 and also see https://pytorch.org/docs/master/compile/troubleshooting.html.\n", + "[2023-07-08 09:19:46,839] torch._dynamo.convert_frame: [WARNING] torch._dynamo hit config.cache_size_limit (64)\n", + " function: '_log' (/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:1514)\n", + "to diagnose recompilation issues, set env variable TORCHDYNAMO_REPORT_GUARD_FAILURES=1 and also see https://pytorch.org/docs/master/compile/troubleshooting.html.\n", + "[2023-07-08 09:19:46,840] torch._dynamo.convert_frame: [WARNING] torch._dynamo hit config.cache_size_limit (64)\n", + " function: '_partial_history_callback' (/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:1383)\n", + "to diagnose recompilation issues, set env variable TORCHDYNAMO_REPORT_GUARD_FAILURES=1 and also see https://pytorch.org/docs/master/compile/troubleshooting.html.\n", + "[2023-07-08 09:19:46,852] torch._dynamo.convert_frame: [WARNING] torch._dynamo hit config.cache_size_limit (64)\n", + " function: 'publish_partial_history' (/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/wandb/sdk/interface/interface.py:555)\n", + "to diagnose recompilation issues, set env variable TORCHDYNAMO_REPORT_GUARD_FAILURES=1 and also see https://pytorch.org/docs/master/compile/troubleshooting.html.\n", + "Epoch 0: 12%| | 635/5308 [12:37<1:32:56, 1.19s/it, v_num=cq44, train/loss=7.41^C\n", + "Process ForkProcess-128:\n", + "Process ForkProcess-127:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "Process ForkProcess-120:\n", + "Process ForkProcess-124:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + "Process ForkProcess-118:\n", + "Process ForkProcess-122:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "Process ForkProcess-123:\n", + "Process ForkProcess-116:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "Process ForkProcess-115:\n", + "Process ForkProcess-112:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "KeyboardInterrupt\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 103, in get\n", + " res = self._recv_bytes()\n", + " ^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/connection.py\", line 215, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/connection.py\", line 413, in _recv_bytes\n", + " buf = self._recv(4)\n", + " ^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/connection.py\", line 378, in _recv\n", + " chunk = read(handle, remaining)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-111:\n", + "Process ForkProcess-109:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-104:\n", + "Process ForkProcess-107:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-102:\n", + "Process ForkProcess-101:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-98:\n", + "Process ForkProcess-99:\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-110:\n", + "Process ForkProcess-100:\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "Process ForkProcess-117:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-103:\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + "Process ForkProcess-108:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-97:\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Process ForkProcess-125:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-126:\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "Process ForkProcess-114:\n", + "KeyboardInterrupt\n", + "Process ForkProcess-121:\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-106:\n", + "Process ForkProcess-113:\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-105:\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Process ForkProcess-119:\n", + "Traceback (most recent call last):\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/pytorch/trainer/call.py:52: UserWarning: Detected KeyboardInterrupt, attempting graceful shutdown...\n", + " rank_zero_warn(\"Detected KeyboardInterrupt, attempting graceful shutdown...\")\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/concurrent/futures/process.py\", line 244, in _process_worker\n", + " call_item = call_queue.get(block=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/queues.py\", line 102, in get\n", + " with self._rlock:\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n" ] } ], @@ -253,7 +690,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -424,7 +861,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -595,7 +1032,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [ { diff --git a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log index ad6325c4..c0effaf1 100644 --- a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log +++ b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log @@ -1,1010 +1,1010 @@ -[2023-07-08 09:31:15,877] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) +[2023-07-08 13:16:17,992] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) [RWKV.model] Running RWKV model via the following optimization mode : torch-compile ninja: no work to do. -[2023-07-08 09:31:29,380] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented -[2023-07-08 09:31:29,381] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. +[2023-07-08 13:16:31,604] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented +[2023-07-08 13:16:31,605] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. [WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096) ninja: no work to do. -Time to load cpu_adam op: 2.3348143100738525 seconds +Time to load cpu_adam op: 2.333820343017578 seconds Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] Training: 0it [00:00, ?it/s] Training: 0%| | 0/1315 [00:00" ] @@ -2895,12 +3667,12 @@ "- JIT: similar starting time, lower accumulative rate\n", "- TCompile: slowest starting time, lowest accumulative rate\n", "\n", - "This can be observed by getting the average time per iteration for the first 200 steps and the last 800 steps" + "This can be observed by getting the average time per iteration for the first 200 steps and the following 2 x 400 steps" ] }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 107, "metadata": {}, "outputs": [ { @@ -2910,39 +3682,57 @@ "Average delta time for the first 200 iterations ('warmup'):\n", "Baseline: 830.0 ms\n", "Jit: 800.0 ms\n", - "TCompile: 775.0 ms\n", + "TCompile: 765.0 ms\n", "\n", - "Average delta time after 'warmup':\n", - "Baseline: 716.2687395891172 ms\n", - "Jit: 686.2853970016657 ms\n", - "TCompile: 665.1860077734592 ms\n" + "Average delta time after 'warmup' for 400 iterations:\n", + "Baseline: 717.5 ms\n", + "Jit: 687.5 ms\n", + "TCompile: 657.5 ms\n", + "\n", + "Average delta time for last 399 iterations:\n", + "Baseline: 714.2857142857143 ms\n", + "Jit: 684.2105263157895 ms\n", + "TCompile: 656.641604010025 ms\n" ] } ], "source": [ "# Compute the average time for the first `n` iterations and for the rest\n", - "def compute_average_delta(data, n):\n", + "def compute_average_time_delta(data, start, end):\n", " time = [x['time'] for x in data]\n", - " avg_first_n = (time[n-1] - time[0]) / n if n > 0 else 0\n", - " avg_remaining = (time[-1] - time[n]) / (len(time)-n) if (len(time)-n) != 0 else 0\n", - " return avg_first_n, avg_remaining\n", + " return (time[end-1] - time[start]) / (end - start)\n", + "\n", + "first_R = 200\n", + "first_R_baseline = compute_average_time_delta(step_baseline, 0, first_R)\n", + "first_R_jit = compute_average_time_delta(step_jit, 0, first_R)\n", + "first_R_tcompile = compute_average_time_delta(step_tcompile, 0, first_R)\n", + "\n", + "next_W = 400\n", + "next_W_baseline = compute_average_time_delta(step_baseline, first_R, first_R + next_W)\n", + "next_W_jit = compute_average_time_delta(step_jit, first_R, first_R + next_W)\n", + "next_W_tcompile = compute_average_time_delta(step_tcompile, first_R, first_R + next_W)\n", "\n", - "n = 200\n", - "avg_delta_baseline = compute_average_delta(step_baseline, n)\n", - "avg_delta_jit = compute_average_delta(step_jit, n)\n", - "avg_delta_tcompile = compute_average_delta(step_tcompile, n)\n", + "next_K = 400\n", + "next_K_baseline = compute_average_time_delta(step_baseline, first_R + next_W, first_R + next_W + next_K)\n", + "next_K_jit = compute_average_time_delta(step_jit, first_R + next_W, first_R + next_W + next_K)\n", + "next_K_tcompile = compute_average_time_delta(step_tcompile, first_R + next_W, first_R + next_W + next_K)\n", + "\n", + "print(f\"Average delta time for the first {first_R} iterations ('warmup'):\")\n", + "print(f\"Baseline: {first_R_baseline * 1000} ms\")\n", + "print(f\"Jit: {first_R_jit * 1000} ms\")\n", + "print(f\"TCompile: {first_R_tcompile * 1000} ms\")\n", + "print(\"\")\n", "\n", - "print(\"Average delta time for the first 200 iterations ('warmup'):\")\n", - "print(f\"Baseline: {avg_delta_baseline[0] * 1000} ms\")\n", - "print(f\"Jit: {avg_delta_jit[0] * 1000} ms\")\n", - "print(f\"TCompile: {avg_delta_tcompile[0] * 1000} ms\")\n", + "print(f\"Average delta time after 'warmup' for {next_W} iterations:\")\n", + "print(f\"Baseline: {next_W_baseline * 1000} ms\")\n", + "print(f\"Jit: {next_W_jit * 1000} ms\")\n", + "print(f\"TCompile: {next_W_tcompile * 1000} ms\")\n", "print(\"\")\n", "\n", - "print(\"Average delta time after 'warmup':\")\n", - "print(f\"Baseline: {avg_delta_baseline[1] * 1000} ms\")\n", - "print(f\"Jit: {avg_delta_jit[1] * 1000} ms\")\n", - "print(f\"TCompile: {avg_delta_tcompile[1] * 1000} ms\")\n", - "\n" + "print(f\"Average delta time for last {next_K} iterations:\")\n", + "print(f\"Baseline: {next_K_baseline * 1000} ms\")\n", + "print(f\"Jit: {next_K_jit * 1000} ms\")\n", + "print(f\"TCompile: {next_K_tcompile * 1000} ms\")\n" ] } ], From 0529e3c655b5028c5d744e6631beb6c3d81a1087 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 14:58:29 +0000 Subject: [PATCH 41/57] optimized torch compile max --- RWKV-v4neo/src/model.py | 37 +- .../logs/torch-compile-perf_torch-compile.log | 2008 ++++++++-------- .../torch-compile-perf.ipynb | 2074 +++++++++-------- 3 files changed, 2075 insertions(+), 2044 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index a17b140d..190c4188 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -55,21 +55,34 @@ def is_torch_version_above(required_version): JITFunction = lambda x: x # PS: i have tried mode="max-autotune", and mode="reduce-overhead", however they crash - # for now. We may introduce them in the future once they are stable - - # TCompileMax, is reserved only for functions we know that can be perfectly compiled - # without any graph breaks - providing the highest level of optimization via torch.compile - TCompileMax = lambda x: torch.compile(x, fullgraph=True) + # for now (8th July 2023). I may introduce them in the future once they are stable + # + # Additionally, torch.compile has issues with the pytorch.lightning module + # --- - # # Baseline, and eager mode are for torch comile operations, that can be partially optimized - # TCompileBaseline = lambda x: torch.compile(x, fullgraph=False) - # TCompileEager = lambda x: torch.compile(x, fullgraph=False, backend="eager") + # We generally have 2 major options, either we use torch.compile + # onto the key top level functions (train, val, test, predict, etc) + # and let the compiler handle all the decision making on how to optimize + # + # However this was found to basically just match JIT level of performance exactly + # --- + # TCompileMax = lambda x: x + # TCompileBaseline = lambda x: torch.compile(x, fullgraph=False) - # We use native lambda, for baseline / eager compile, as current benchmark shows that - # it is generally faster to leave them as native python functions instead - # (this may change in the future as torch.compile improves) + # Alternatively, we can perform a much more aggressive optimization on critical functions + # that we know are compatible with torch.compile(fullgraph=True) - which provides the highest + # level of optimization possible with torch.compile + # --- + TCompileMax = lambda x: torch.compile(x, fullgraph=True) TCompileBaseline = lambda x: x + # --- + # Because torch.compile is expected to change overtime, the two options should + # be tested every now and then, for any performance changes + # + # and we should switch over to the broaded automated approach if its "faster" + # --- + # Used to wrap functions which are **not** torch.compile compatible TCompileDisable = torch._dynamo.disable @@ -101,6 +114,8 @@ def is_torch_version_above(required_version): # --- # Isolating out known operations that **does not work** with torch.compile +# and wrapping them within a torch._dynamo.disable, this is required to get +# the baseline torc.compile to work # --- @TCompileDisable diff --git a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log index c0effaf1..962f3ecc 100644 --- a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log +++ b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log @@ -1,1010 +1,1010 @@ -[2023-07-08 13:16:17,992] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) +[2023-07-08 14:32:07,798] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) [RWKV.model] Running RWKV model via the following optimization mode : torch-compile ninja: no work to do. -[2023-07-08 13:16:31,604] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented -[2023-07-08 13:16:31,605] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. +[2023-07-08 14:32:21,137] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented +[2023-07-08 14:32:21,138] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. [WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096) ninja: no work to do. -Time to load cpu_adam op: 2.333820343017578 seconds +Time to load cpu_adam op: 2.3387460708618164 seconds Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] Training: 0it [00:00, ?it/s] Training: 0%| | 0/1315 [00:00" ] @@ -3555,12 +3568,12 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 113, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3613,12 +3626,12 @@ }, { "cell_type": "code", - "execution_count": 104, + "execution_count": 114, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3672,7 +3685,7 @@ }, { "cell_type": "code", - "execution_count": 107, + "execution_count": 115, "metadata": {}, "outputs": [ { @@ -3682,17 +3695,17 @@ "Average delta time for the first 200 iterations ('warmup'):\n", "Baseline: 830.0 ms\n", "Jit: 800.0 ms\n", - "TCompile: 765.0 ms\n", + "TCompile: 795.0 ms\n", "\n", "Average delta time after 'warmup' for 400 iterations:\n", "Baseline: 717.5 ms\n", "Jit: 687.5 ms\n", - "TCompile: 657.5 ms\n", + "TCompile: 687.5 ms\n", "\n", - "Average delta time for last 399 iterations:\n", - "Baseline: 714.2857142857143 ms\n", - "Jit: 684.2105263157895 ms\n", - "TCompile: 656.641604010025 ms\n" + "Average delta time for last 400 iterations:\n", + "Baseline: 717.5 ms\n", + "Jit: 687.5 ms\n", + "TCompile: 687.5 ms\n" ] } ], @@ -3700,12 +3713,15 @@ "# Compute the average time for the first `n` iterations and for the rest\n", "def compute_average_time_delta(data, start, end):\n", " time = [x['time'] for x in data]\n", - " return (time[end-1] - time[start]) / (end - start)\n", + " if start == -1:\n", + " return (time[end-1]) / (end)\n", + " else:\n", + " return (time[end-1] - time[start]) / (end - start)\n", "\n", "first_R = 200\n", - "first_R_baseline = compute_average_time_delta(step_baseline, 0, first_R)\n", - "first_R_jit = compute_average_time_delta(step_jit, 0, first_R)\n", - "first_R_tcompile = compute_average_time_delta(step_tcompile, 0, first_R)\n", + "first_R_baseline = compute_average_time_delta(step_baseline, -1, first_R)\n", + "first_R_jit = compute_average_time_delta(step_jit, -1, first_R)\n", + "first_R_tcompile = compute_average_time_delta(step_tcompile, -1, first_R)\n", "\n", "next_W = 400\n", "next_W_baseline = compute_average_time_delta(step_baseline, first_R, first_R + next_W)\n", From c839b231689b33c30455edda518e089e7b8e9430 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 16:17:09 +0000 Subject: [PATCH 42/57] fix a dataset column typo --- RWKV-v4neo/src/data.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RWKV-v4neo/src/data.py b/RWKV-v4neo/src/data.py index 03eb7e54..c83cceed 100644 --- a/RWKV-v4neo/src/data.py +++ b/RWKV-v4neo/src/data.py @@ -307,7 +307,7 @@ def __init__( multi_column_keys: list = None, multi_column_prefix: list = None, multi_column_masking: list = None, - multi_column_separator: str = None, + multi_column_seperator: str = None, # prompt/completion format masking support disable_prompt_mask: bool = False ): From 229ba126c4108ea240ffa9c76e495236b50c1539 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 16:38:22 +0000 Subject: [PATCH 43/57] Fixing the separator typo --- RWKV-v4neo/src/data.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/RWKV-v4neo/src/data.py b/RWKV-v4neo/src/data.py index c83cceed..eb56e82c 100644 --- a/RWKV-v4neo/src/data.py +++ b/RWKV-v4neo/src/data.py @@ -59,7 +59,7 @@ def prepare_data_static(**kargs): # Tokenized encodings for multi column keys multi_column_enabled = len(multi_column_keys) > 0 multi_column_prefix_encodings = [] - multi_column_seperator_encodings = None + multi_column_separator_encodings = None # Process the multi column settings if multi_column_enabled: @@ -69,9 +69,9 @@ def prepare_data_static(**kargs): # Tokenize the multi column strings for i in range(len(multi_column_keys)): multi_column_prefix_encodings.append(tokenizer(multi_column_prefix[i])) - # Tokenize the multi column seperator + # Tokenize the multi column separator if multi_column_separator is not None and len(multi_column_separator) > 0: - multi_column_seperator_encodings = tokenizer(multi_column_separator) + multi_column_separator_encodings = tokenizer(multi_column_separator) # Maps the dataset record to the tokenized result # handles a wide variety of format according to the data configuration @@ -112,11 +112,11 @@ def map_tokenizer(x): for i in range(len(multi_column_keys)): # And process the column if it has data if multi_column_keys[i] in x and x[multi_column_keys[i]] is not None and len(x[multi_column_keys[i]]) > 0: - # Add the seperator if this is not the first item - if not is_first_item and multi_column_seperator_encodings is not None: - input_ids += multi_column_seperator_encodings['input_ids'] - token_type_ids += multi_column_seperator_encodings['token_type_ids'] - attention_mask += multi_column_seperator_encodings['attention_mask'] + # Add the separator if this is not the first item + if not is_first_item and multi_column_separator_encodings is not None: + input_ids += multi_column_separator_encodings['input_ids'] + token_type_ids += multi_column_separator_encodings['token_type_ids'] + attention_mask += multi_column_separator_encodings['attention_mask'] # Add the prefix input_ids += multi_column_prefix_encodings[i]['input_ids'] @@ -307,7 +307,7 @@ def __init__( multi_column_keys: list = None, multi_column_prefix: list = None, multi_column_masking: list = None, - multi_column_seperator: str = None, + multi_column_separator: str = None, # prompt/completion format masking support disable_prompt_mask: bool = False ): From 68538dda012d5cb960d9a67d8d3f6d33c36663ec Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 16:46:50 +0000 Subject: [PATCH 44/57] fix config typo --- notebook/trainer-validation/config/baseline-1024.yaml | 2 +- notebook/trainer-validation/config/baseline-dryrun.yaml | 2 +- notebook/trainer-validation/config/torch-compile-perf.yaml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/notebook/trainer-validation/config/baseline-1024.yaml b/notebook/trainer-validation/config/baseline-1024.yaml index ab894943..3acc501e 100644 --- a/notebook/trainer-validation/config/baseline-1024.yaml +++ b/notebook/trainer-validation/config/baseline-1024.yaml @@ -325,7 +325,7 @@ data: # multi_column_keys: ['instruction', 'input', 'output'] # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' + # multi_column_separator: '\n\n' # If processing prompt/completion jsonl pairs, the prompt is masked by default # use this flag to disable this default behaviour diff --git a/notebook/trainer-validation/config/baseline-dryrun.yaml b/notebook/trainer-validation/config/baseline-dryrun.yaml index 0e1abedb..a76ee3a5 100644 --- a/notebook/trainer-validation/config/baseline-dryrun.yaml +++ b/notebook/trainer-validation/config/baseline-dryrun.yaml @@ -325,7 +325,7 @@ data: # multi_column_keys: ['instruction', 'input', 'output'] # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' + # multi_column_separator: '\n\n' # If processing prompt/completion jsonl pairs, the prompt is masked by default # use this flag to disable this default behaviour diff --git a/notebook/trainer-validation/config/torch-compile-perf.yaml b/notebook/trainer-validation/config/torch-compile-perf.yaml index 0ca3a7ef..74f6457c 100644 --- a/notebook/trainer-validation/config/torch-compile-perf.yaml +++ b/notebook/trainer-validation/config/torch-compile-perf.yaml @@ -328,7 +328,7 @@ data: # multi_column_keys: ['instruction', 'input', 'output'] # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' + # multi_column_separator: '\n\n' # If processing prompt/completion jsonl pairs, the prompt is masked by default # use this flag to disable this default behaviour From e3fc40777e2ea1854a5b88f6466b13cc0b27ebfa Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 16:58:06 +0000 Subject: [PATCH 45/57] typo fix --- RWKV-v4neo/config-example.yaml | 35 +++++++++++-------- .../matmul-medium-precision.yaml | 2 +- 2 files changed, 22 insertions(+), 15 deletions(-) diff --git a/RWKV-v4neo/config-example.yaml b/RWKV-v4neo/config-example.yaml index eb5cf08d..e0c7c8a4 100644 --- a/RWKV-v4neo/config-example.yaml +++ b/RWKV-v4neo/config-example.yaml @@ -195,14 +195,6 @@ model: # without eating up too much vram by keeping the training context length # to a resonable number sutible to the current GPU setup ctx_len: 2048 - # Data samples would be cut down to the respective max ctx_len_cutoffs - # values if its larger then ctx_len. If the data sample is larger then - # the largest len_cutoff, the remaining data will be discarded - ctx_len_cutoffs: [8192, 16384, 32768, 65536] - # Experimental settings, number of tokens to skip in the data sample - # prefix, for the respective cutoff length. Used to speed up the process - ctx_len_warmup_steps: [0, 0, 0, 0] - # Learning rate of the training process lr_init: 1.0e-04 @@ -213,11 +205,6 @@ model: adam_eps: 1.0e-08 weight_decay: 0.01 - # torch.set_float32_matmul_precision, used to optimize operations with tensor cores - # this should be set as null, for non cuda core GPUs - torch_set_float32_matmul_precision: 'high' - # torch_set_float32_matmul_precision: null - # Back Propagation through time, used to work around training of large context length # beyond what can be supported by the current GPU vram architecture # @@ -248,6 +235,26 @@ model: # `1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance...` substep_cuda_cache_clear: false + + # Experimental cutoff settings + # --- + # Data samples would be cut down to the respective max ctx_len_cutoffs + # values if its larger then ctx_len. If the data sample is larger then + # the largest len_cutoff, the remaining data will be discarded + # + # Leave it as a blank array to disable the feature + ctx_len_cutoffs: [] + # Experimental settings, number of tokens to skip in the data sample + # prefix, for the respective cutoff length. Used to speed up the process + # + # Leave it as a blank array to disable the feature + ctx_len_warmup_steps: [] + + # torch.set_float32_matmul_precision, used to optimize operations with tensor cores + # this should be set as null, for non cuda core GPUs + torch_set_float32_matmul_precision: 'high' + # torch_set_float32_matmul_precision: null + # various other settings you probably should leave alone grad_cp: true warmup_steps: -1 @@ -330,7 +337,7 @@ data: # multi_column_keys: ['instruction', 'input', 'output'] # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' + # multi_column_separator: '\n\n' # If processing prompt/completion jsonl pairs, the prompt is masked by default # use this flag to disable this default behaviour diff --git a/notebook/trainer-validation/matmul-medium-precision.yaml b/notebook/trainer-validation/matmul-medium-precision.yaml index 44159dcf..9fed74e7 100644 --- a/notebook/trainer-validation/matmul-medium-precision.yaml +++ b/notebook/trainer-validation/matmul-medium-precision.yaml @@ -325,7 +325,7 @@ data: # multi_column_keys: ['instruction', 'input', 'output'] # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] # multi_column_masking: [false, true, false] - # multi_column_seperator: '\n\n' + # multi_column_separator: '\n\n' # If processing prompt/completion jsonl pairs, the prompt is masked by default # use this flag to disable this default behaviour From 154f949ccbca8ccb2b27f07d982e7e57450f78d3 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sat, 8 Jul 2023 17:17:21 +0000 Subject: [PATCH 46/57] optimizing the TCompileMax options --- RWKV-v4neo/src/model.py | 35 +- .../logs/torch-compile-perf_torch-compile.log | 2008 ++++++++--------- 2 files changed, 1013 insertions(+), 1030 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 190c4188..0e605925 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -47,7 +47,7 @@ def is_torch_version_above(required_version): # We enable JITMod*/Function when supporting torch.jit # We use TorchCompile* when supporting torch compile # based on the current runtime settings -if RWKV_TORCH_COMPILE: +if RWKV_TORCH_COMPILE and torch._dynamo is not None: RWKV_TORCH_RUN_MODE = "torch-compile" JITModClass = nn.Module @@ -57,7 +57,7 @@ def is_torch_version_above(required_version): # PS: i have tried mode="max-autotune", and mode="reduce-overhead", however they crash # for now (8th July 2023). I may introduce them in the future once they are stable # - # Additionally, torch.compile has issues with the pytorch.lightning module + # Additionally, torch.compile has issues with the pytorch.lightning module directly # --- # We generally have 2 major options, either we use torch.compile @@ -157,6 +157,7 @@ def __init__(self, shift_states, wkv_states): self.wkv_states = wkv_states self.shift_states = shift_states + # @ TCompileMax (no difference) @staticmethod def create(N, B, C, device, dtype): result = BlockStateList.empty(N, B, C, device, dtype) @@ -165,6 +166,7 @@ def create(N, B, C, device, dtype): result.shift_states[:] = 0 return result + # @ TCompileMax (no difference) @staticmethod def empty(N, B, C, device, dtype): wkv_states = torch.empty((N, B, C, 3), @@ -334,12 +336,11 @@ def forward(ctx, loss, y, token_amount, currentMask): # Currently (8th July 2023), save_for_backward, causes an issue with # pytorch.compile (see: https://github.com/pytorch/pytorch/blob/e600505e3209eaf539e8bc99870ea55236cefbf5/torch/_dynamo/variables/higher_order_ops.py#L735) # - # Due to L2Wrap being a major hotspot, we should monitor this status + # Due to L2Wrap being a major hotspot, we should monitor this for future support. # so that once its resolved, we can include the L2Wrap step in the torch.compile path # # See also: # - checkpointed_step - # - _RWKV_checkpointed_step_optimized ctx.save_for_backward(y) ctx.token_amount = token_amount ctx.currentMask = currentMask @@ -361,19 +362,9 @@ def backward(ctx, grad_output): # Static optimized functions ######################################################################################################## -# @ TCompileMax -# def _RWKV_checkpointed_step_optimized( -# logits, new_shift_states, new_wkv_states, -# idx, targets, mask, prev_loss, last_shift_states, last_wkv_states, prev_steps, -# total_mask_sum -# ): -# loss = F.cross_entropy(logits.view(-1, logits.size(-1)), -# targets.view(-1), -# reduction="none") -# submask = mask.view(-1)[:loss.shape[0]] -# submask_sum = torch.sum(submask) -# loss = torch.sum(loss * submask) / total_mask_sum -# return loss, submask, submask_sum +# @ TCompileMax (no speed improvement) +# def F_cross_entropy_reduction_none_optimized(logits, targets): +# return F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), reduction="none") ######################################################################################################## # Core RWKV module @@ -785,18 +776,10 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, logits, new_shift_states, new_wkv_states = self( idx, last_shift_states, last_wkv_states) - # # If torch.compile is enabled, this is a heavily optimized varient - # # (especially on F.cross_entropy) else its just another static function - # loss, submask, submask_sum = _RWKV_checkpointed_step_optimized( - # logits, new_shift_states, new_wkv_states, - # idx, targets, mask, prev_loss, - # last_shift_states, last_wkv_states, prev_steps, - # total_mask_sum - # ) - loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), reduction="none") + submask = mask.view(-1)[:loss.shape[0]] submask_sum = torch.sum(submask) loss = torch.sum(loss * submask) / total_mask_sum diff --git a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log index 962f3ecc..6dd003b1 100644 --- a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log +++ b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log @@ -1,1010 +1,1010 @@ -[2023-07-08 14:32:07,798] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) +[2023-07-08 16:50:16,851] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) [RWKV.model] Running RWKV model via the following optimization mode : torch-compile ninja: no work to do. -[2023-07-08 14:32:21,137] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented -[2023-07-08 14:32:21,138] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. +[2023-07-08 16:50:30,413] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented +[2023-07-08 16:50:30,414] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. [WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096) ninja: no work to do. -Time to load cpu_adam op: 2.3387460708618164 seconds +Time to load cpu_adam op: 2.3341588973999023 seconds Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] Training: 0it [00:00, ?it/s] Training: 0%| | 0/1315 [00:00 Date: Sat, 8 Jul 2023 19:35:15 +0000 Subject: [PATCH 47/57] more TCompileMax tuning --- RWKV-v4neo/config-example.yaml | 1 - RWKV-v4neo/src/model.py | 2 +- .../config/torch-compile-perf.yaml | 32 +- .../logs/torch-compile-perf_baseline.log | 2010 +++++----- .../logs/torch-compile-perf_jit.log | 2008 +++++----- .../logs/torch-compile-perf_torch-compile.log | 2008 +++++----- .../torch-compile-perf.ipynb | 3236 +---------------- 7 files changed, 3106 insertions(+), 6191 deletions(-) diff --git a/RWKV-v4neo/config-example.yaml b/RWKV-v4neo/config-example.yaml index e0c7c8a4..5e67c7a7 100644 --- a/RWKV-v4neo/config-example.yaml +++ b/RWKV-v4neo/config-example.yaml @@ -235,7 +235,6 @@ model: # `1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance...` substep_cuda_cache_clear: false - # Experimental cutoff settings # --- # Data samples would be cut down to the respective max ctx_len_cutoffs diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 0e605925..10a43b73 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -247,7 +247,7 @@ def _forward_kvsr(self, x, last_state: TimeMixState): return k, v, sr @JITModMethod - @TCompileMax + # @ TCompileMax (performs better without TCompileMax) def _forward_out(self, sr, y, x_l, new_wkv_state): return self.output(sr * y), TimeMixState(x_l, new_wkv_state) diff --git a/notebook/trainer-validation/config/torch-compile-perf.yaml b/notebook/trainer-validation/config/torch-compile-perf.yaml index 74f6457c..970f1189 100644 --- a/notebook/trainer-validation/config/torch-compile-perf.yaml +++ b/notebook/trainer-validation/config/torch-compile-perf.yaml @@ -191,14 +191,6 @@ model: # to a resonable number sutible to the current GPU setup ctx_len: 4096 - # Data samples would be cut down to the respective max ctx_len_cutoffs - # values if its larger then ctx_len. If the data sample is larger then - # the largest len_cutoff, the remaining data will be discarded - ctx_len_cutoffs: [4096, 8192, 16384, 32768, 65536] - # Experimental settings, number of tokens to skip in the data sample - # prefix, for the respective cutoff length. Used to speed up the process - ctx_len_warmup_steps: [0, 0, 0, 0, 0] - # Learning rate of the training process # --- # Initia learning rate of the process @@ -224,11 +216,6 @@ model: adam_eps: 1.0e-08 weight_decay: 0.01 - # torch.set_float32_matmul_precision, used to optimize operations with tensor cores - # this should be set as null, for non cuda core GPUs - torch_set_float32_matmul_precision: 'high' - # torch_set_float32_matmul_precision: null - # Segmented based learning, used to work around training of large context length # beyond what can be supported by the current GPU vram architecture # @@ -245,6 +232,25 @@ model: # Force each substep to be logged as a seperate line substep_logging: true + # Experimental cutoff settings + # --- + # Data samples would be cut down to the respective max ctx_len_cutoffs + # values if its larger then ctx_len. If the data sample is larger then + # the largest len_cutoff, the remaining data will be discarded + # + # Leave it as a blank array to disable the feature + ctx_len_cutoffs: [] + # Experimental settings, number of tokens to skip in the data sample + # prefix, for the respective cutoff length. Used to speed up the process + # + # Leave it as a blank array to disable the feature + ctx_len_warmup_steps: [] + + # torch.set_float32_matmul_precision, used to optimize operations with tensor cores + # this should be set as null, for non cuda core GPUs + torch_set_float32_matmul_precision: 'high' + # torch_set_float32_matmul_precision: null + # various other settings you probably should leave alone grad_cp: true warmup_steps: -1 diff --git a/notebook/trainer-validation/logs/torch-compile-perf_baseline.log b/notebook/trainer-validation/logs/torch-compile-perf_baseline.log index 64bde882..7162a4da 100644 --- a/notebook/trainer-validation/logs/torch-compile-perf_baseline.log +++ b/notebook/trainer-validation/logs/torch-compile-perf_baseline.log @@ -1,1010 +1,1010 @@ -[2023-07-08 05:13:47,599] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) -[RWKV.model] Running RWKV model with : torch-native +[2023-07-08 17:51:59,139] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) +[RWKV.model] Running RWKV model via the following optimization mode : torch-native ninja: no work to do. -[2023-07-08 05:14:01,190] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented -[2023-07-08 05:14:01,191] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. +[2023-07-08 17:52:12,529] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented +[2023-07-08 17:52:12,530] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. [WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096) ninja: no work to do. -Time to load cpu_adam op: 2.3342676162719727 seconds +Time to load cpu_adam op: 2.326359748840332 seconds Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] Training: 0it [00:00, ?it/s] Training: 0%| | 0/1315 [00:00" ] @@ -3568,12 +477,12 @@ }, { "cell_type": "code", - "execution_count": 113, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3626,12 +535,12 @@ }, { "cell_type": "code", - "execution_count": 114, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3685,7 +594,7 @@ }, { "cell_type": "code", - "execution_count": 115, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -3693,19 +602,19 @@ "output_type": "stream", "text": [ "Average delta time for the first 200 iterations ('warmup'):\n", - "Baseline: 830.0 ms\n", - "Jit: 800.0 ms\n", - "TCompile: 795.0 ms\n", + "Baseline: 875.0 ms\n", + "Jit: 860.0 ms\n", + "TCompile: 1140.0 ms\n", "\n", "Average delta time after 'warmup' for 400 iterations:\n", "Baseline: 717.5 ms\n", "Jit: 687.5 ms\n", - "TCompile: 687.5 ms\n", + "TCompile: 655.0 ms\n", "\n", "Average delta time for last 400 iterations:\n", - "Baseline: 717.5 ms\n", + "Baseline: 715.0 ms\n", "Jit: 687.5 ms\n", - "TCompile: 687.5 ms\n" + "TCompile: 657.5 ms\n" ] } ], @@ -3718,6 +627,7 @@ " else:\n", " return (time[end-1] - time[start]) / (end - start)\n", "\n", + "# PS, [0] pos shows the timing for the first step, so we use -1 to start from \"0\"\n", "first_R = 200\n", "first_R_baseline = compute_average_time_delta(step_baseline, -1, first_R)\n", "first_R_jit = compute_average_time_delta(step_jit, -1, first_R)\n", From 6f96df5d28b581e0c77d43f3f97a125cf0fb4443 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sun, 9 Jul 2023 05:05:26 +0000 Subject: [PATCH 48/57] Finalizing the torch compile tune --- RWKV-v4neo/src/model.py | 2 +- .../logs/torch-compile-perf_torch-compile.log | 2008 ++++++++--------- .../torch-compile-perf.ipynb | 1108 ++++++++- 3 files changed, 2089 insertions(+), 1029 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 10a43b73..0e605925 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -247,7 +247,7 @@ def _forward_kvsr(self, x, last_state: TimeMixState): return k, v, sr @JITModMethod - # @ TCompileMax (performs better without TCompileMax) + @TCompileMax def _forward_out(self, sr, y, x_l, new_wkv_state): return self.output(sr * y), TimeMixState(x_l, new_wkv_state) diff --git a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log index c4175790..885d60c2 100644 --- a/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log +++ b/notebook/trainer-validation/logs/torch-compile-perf_torch-compile.log @@ -1,1010 +1,1010 @@ -[2023-07-08 18:42:11,574] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) +[2023-07-09 03:53:13,342] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect) [RWKV.model] Running RWKV model via the following optimization mode : torch-compile ninja: no work to do. -[2023-07-08 18:42:25,583] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented -[2023-07-08 18:42:25,584] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. +[2023-07-09 03:53:26,844] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented +[2023-07-09 03:53:26,845] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`. [WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096) ninja: no work to do. -Time to load cpu_adam op: 2.3347737789154053 seconds +Time to load cpu_adam op: 2.3317573070526123 seconds Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] Training: 0it [00:00, ?it/s] Training: 0%| | 0/1315 [00:00" ] @@ -477,12 +1537,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -535,12 +1595,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -594,7 +1654,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -604,17 +1664,17 @@ "Average delta time for the first 200 iterations ('warmup'):\n", "Baseline: 875.0 ms\n", "Jit: 860.0 ms\n", - "TCompile: 1140.0 ms\n", + "TCompile: 1125.0 ms\n", "\n", "Average delta time after 'warmup' for 400 iterations:\n", - "Baseline: 717.5 ms\n", - "Jit: 687.5 ms\n", - "TCompile: 655.0 ms\n", + "Baseline: 715.0 ms\n", + "Jit: 685.0 ms\n", + "TCompile: 652.5 ms\n", "\n", "Average delta time for last 400 iterations:\n", - "Baseline: 715.0 ms\n", + "Baseline: 717.5 ms\n", "Jit: 687.5 ms\n", - "TCompile: 657.5 ms\n" + "TCompile: 655.0 ms\n" ] } ], From f597ed14d2a495aa4b6cb5d31fe692b59bf7fbfc Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sun, 9 Jul 2023 05:06:35 +0000 Subject: [PATCH 49/57] dropped matmul precision file --- .../matmul-medium-precision.yaml | 339 ------------------ 1 file changed, 339 deletions(-) delete mode 100644 notebook/trainer-validation/matmul-medium-precision.yaml diff --git a/notebook/trainer-validation/matmul-medium-precision.yaml b/notebook/trainer-validation/matmul-medium-precision.yaml deleted file mode 100644 index 9fed74e7..00000000 --- a/notebook/trainer-validation/matmul-medium-precision.yaml +++ /dev/null @@ -1,339 +0,0 @@ -# lightning.pytorch==2.0.2 -seed_everything: 3941088705 -trainer: - # Configure the number of GPU, avaliable on your machine - accelerator: gpu - devices: 1 - num_nodes: 1 - - # - # Configure the deepspeed strategy, we recommend you start with `deepspeed_stage_2_offload` - # and adjust from there according to your training needs. `deepspeed_stage_3_offload` is useful - # for training LoRA on large models on a single GPU. - # - # In general you would want to use the following: - # - # - deepspeed_stage_1 : Each of your GPU has too much vram, and you do not know what to do - # - # - deepspeed_stage_2 : Optimal distributed training strategy, across multiple gpu each with sufficient vram - # - deepspeed_stage_2_offload : Reduce vram usage by offloading the optimizer state and work to cpu - # - # - deepspeed_stage_3 : Split up the model across multiple gpu, useful for large models, at a performance cost - # - deepspeed_stage_3_offload : Additional offloading, for even greater performance cost - # - # For more details see: - # https://lightning.ai/docs/pytorch/stable/advanced/model_parallel.html#deepspeed-zero-stage-2 - # - strategy: deepspeed_stage_2_offload - - # Floating point precision for the model, because RWKV is built FOR bf16 - # you should pretty much never change this setting - precision: bf16 - - # Logger setting for wandb, if you want to enable wandb, uncomment the whole logger section - # --- - logger: - class_path: lightning.pytorch.loggers.WandbLogger - init_args: - name: 'infctx-validation-full (matmul=medium, train-ctx=1024, data-ctx=1024, bs=12)' - project: 'RWKV-infctx-validation' - tags: ['RWKV', 'infctx'] - id: null - save_dir: . - version: null - offline: false - dir: null - anonymous: null - log_model: false - experiment: null - prefix: '' - checkpoint_name: null - job_type: null - config: null - entity: null - reinit: null - group: null - notes: null - magic: null - config_exclude_keys: null - config_include_keys: null - mode: null - allow_val_change: null - resume: null - force: null - tensorboard: null - sync_tensorboard: null - monitor_gym: null - save_code: null - settings: null - - # Checkpoint settings for the training process - callbacks: - - class_path: lightning.pytorch.callbacks.ModelCheckpoint - init_args: - # Configure this to the path you want to save your checkpoints to - # note that a subdir will be created with the name `epoch=x-step=y.ckpt` - # - # to convert a checkpoint to a model, you can use the - # `python3 export_checkpoint.py ` script, - # which will create a `rwkv_model.pth` in the checkpoint directory. - # - # Do not use the `zero_to_fp32.py` script as that will have export format issues - dirpath: ../checkpoint/trainer-validaiton/matmul-medium - filename: null - - # Save the top/last K checkpoints - save_top_k: 3 - # Choose by the most recent checkpoints (step based) - monitor: 'step' - mode: max - - # If enabled (true), save a copy of the latest checkpoint to 'last.ckpt' - # useful to simply checkpoint resume scripts, at a price of disk performance - save_last: false - - # DO NOT set this as true, as the model weight exported will have format issues - # expert as checkpoint, and use the `export_checkpoint.py` script to convert to model instead - save_weights_only: false - - # How frequent you want to save a checkpoint for every step. - # This will happen for every X data sample, where X = every_n_train_steps * accumulate_grad_batches - # - # In general you will want to avoid putting a low number (expecially if accumulate_grad_batches <= 100) - # as the checkpoint process, will pause all the gpu training for some time, slowing down the overall process - # However you do not want to configure too high of a number, where you will lose too much progress if the training crashes - every_n_train_steps: 5000 - every_n_epochs: null - save_on_train_epoch_end: true - train_time_interval: null - - # Other settings, you can probably leave alone - verbose: false - auto_insert_metric_name: true - - ######################################## - ## Training run parameter settings - ######################################## - - # Generally what you want to configure is the maximum number of epochs - # Leave it as -1, and it will keep going forever till interrupted - # Or set it as a number, and it will stop after that number of epochs - max_epochs: 1 - min_epochs: null - max_steps: -1 - min_steps: null - max_time: null - - # Number of datasamples to train for each step, a data sample is considered - # a "substep" in wandb logs, and a "step" is tracked as "trainer/global_step" - # - # This decides the number of datasample, to learn together from, before backproping - # any weight changes at the end of the batch. - # - # Recommended to be a big enough number (like 128/256) where it prevents the training - # loss from flucuating in the process. But not too big of a number where the increased - # GPU vRAM / offloaded RAM usage will cause the training to crash. - # - # You are also recommended to configure this to a large enough number to fully utilize - # your GPU processing time %, and avoid idle time for the GPU between batches - accumulate_grad_batches: 12 - - # Various other settings, you probably want to leave alone - fast_dev_run: false - limit_train_batches: null - limit_val_batches: null - limit_test_batches: null - limit_predict_batches: null - overfit_batches: 0.0 - val_check_interval: null - check_val_every_n_epoch: 1 - num_sanity_val_steps: 0 - log_every_n_steps: 1 - enable_checkpointing: true - enable_progress_bar: null - enable_model_summary: null - gradient_clip_val: 1.0 - gradient_clip_algorithm: null - deterministic: null - benchmark: null - inference_mode: true - use_distributed_sampler: true - profiler: null - detect_anomaly: false - barebones: false - plugins: null - sync_batchnorm: false - reload_dataloaders_every_n_epochs: 0 - default_root_dir: null - -######################################## -## Training model settings -######################################## -model: - # Model to start the finetune/training process from - load_model: ../model/Echo-A-1B5-Init.pth - - # The model size setting, this MUST match - # your current model settings, refer to the model card - # of the downloaded model for more details - n_embd: 2048 - n_layer: 24 - vocab_size: 50277 - - # Context length to use for the training process - # the larger the number (and batch size) the larger the vram usage - # - # Note that if the datasample context length is larger then the ctx_len - # its training process would be split into ctx_len sized chunks. - # - # This allows the training of extreamly large context length (eg. 100k), - # without eating up too much vram by keeping the training context length - # to a resonable number sutible to the current GPU setup - ctx_len: 1024 - - # Data samples would be cut down to the respective max ctx_len_cutoffs - # values if its larger then ctx_len. If the data sample is larger then - # the largest len_cutoff, the remaining data will be discarded - ctx_len_cutoffs: [1024, 2048, 4096, 8192, 16384, 32768, 65536] - # Experimental settings, number of tokens to skip in the data sample - # prefix, for the respective cutoff length. Used to speed up the process - ctx_len_warmup_steps: [0, 0, 0, 0, 0, 0, 0] - - # Learning rate of the training process - # --- - # Initia learning rate of the process - lr_init: 6e-4 - # Final learning rate after the learning rate period - # learning rate will stay at final value from then onwards - # - # NOTE: lr_final / lr_period does not work with warmup_steps - # and will be ignored (or replaced) with the warmup_steps logic instead - lr_final: 4e-4 - # Number of epoch to reduce the learning rate from lr_init to lr_final - # 1 means a single epoch (so lr would be lr_final from epoch 2 onwards) - # 0 means lr_final will apply immediately - # -1 means we take the current max_step / max_epoch as the period - lr_period: 1 - # lr_period type if its set, defaults to epoch - lr_period_type: epoch - - # Adam optimizer settings - # You probably want to leave this alone, unless you know what you are doing - beta1: 0.9 - beta2: 0.99 - adam_eps: 1.0e-08 - weight_decay: 0.01 - - # torch.set_float32_matmul_precision, used to optimize operations with tensor cores - # this should be set as null, for non cuda core GPUs - torch_set_float32_matmul_precision: 'medium' - # torch_set_float32_matmul_precision: null - - # Segmented based learning, used to work around training of large context length - # beyond what can be supported by the current GPU vram architecture - # - # This is not 1:1 equivalent to the same training process with required vram - # as the training process is split into multiple segments, part by part. - # with limited learnings from the previous segment. - bptt_learning: false - - # Segmented range to performing backprop learning on - # 1 means to apply only for the last segment - # -1 means to apply for all segments - bptt_learning_range: -1 - - # various other settings you probably should leave alone - grad_cp: true - warmup_steps: -1 - layerwise_lr: true - dim_att: null - dim_ffn: null -data: - # dataset_path for the prebuilt dataset, using HF `load_from_disk()` - # - # Use this if you have built your own dataset and saved it with `save_to_disk()` - # with source left as null. Other wise configure this to a directory which the - # dataset will be built and tokenized by the huggingface dataset process. - data_path: ../datapath/enwiki_10k_1024/ - - # Other wise provide the source path, which is used as huggingface dataset path - # this will be used to populate the dataset_path - # - # Use either the following - # - hugging face dataset - # - Directory path to a directory containing dataset files - # - Path to a single dataset file - # - hugging face dataset mode (ie: text,csv,etc - use data_dir, to configure the path then) - # - null - # - # If source is disabled, all other params, except data_path, is ignored - source: "teven/enwiki_10k" - # source: text - # source: /home/ubuntu/RWKV-LM-LoRA/dataset-text/enwik8.txt - - # Use data_dir, if you are using source=text/json/etc - # this should be relative to the data_path - source_data_dir: null - - # After loading the dataset, split out test data used for validation, - # This process is skipped if the dataset includes a test split - # This process is skipped if set to zero - test_split: 0.01 - test_split_shuffle: false - - # Tokenizer to use, use either the inbuilt 'neox', or 'world' tokenizer - # If using a custom tokenizer, provide the tokenizer file path - # --- - tokenizer: neox - - # Minimum / Maximum token size of the dataset to use - # useful for filtering out small noisy data samples from large datasets - # (eg. removal of small articles of less then 512 tokens from wikipedia) - # - # This is ignored, if set to -1 - min_token_size: 64 - max_token_size: -1 - - # Rechunking of text dataset, this is done only when source is set as 'text' - # and will merge the various sentencees, into larger chunks up to the target size - # - # Defaults to 4096 - # - # This is ignored, if source is not set as text - # This is ignored, if set to zero - # --- - text_rechunk_size: 1024 - - # Apply text rechunk to the dataset, even if its not a 'text' source - # This is done only after dataset filtering, and if source is not 'text' - # --- - text_rechunk_force: true - - # Custom text column to use, useful for dataset with alternative training columns labels - # This is checked before multi column merging, default is null (disabled) - # eg: 'code' - # --- - # custom_text_key: 'code' - - # Multi Column merging process, default setting is used to support and merge - # "instruction", "input", "output", datasets. To disable set multi_column_keys to [] - # - # A minimum of 2 columns is required, with non empty data, for the merge to occur - # If no match is found, this will fallback to the default prompt/completion or text column, - # or throw an error if the default fallback is not found - # --- - # multi_column_keys: ['instruction', 'input', 'output'] - # multi_column_prefix: ['Instruction:\n', 'Input:\n', 'Output:\n'] - # multi_column_masking: [false, true, false] - # multi_column_separator: '\n\n' - - # If processing prompt/completion jsonl pairs, the prompt is masked by default - # use this flag to disable this default behaviour - # --- - # disable_prompt_mask: false - -# Path to the current checkpoint to continue training from -# Enable this to the last checkpoint after the first run -# (if it crash and you want to resume) -# ckpt_path: ../checkpoint/trainer-validaiton/infctx-validation-dryrun/epoch=0-step=20.ckpt -ckpt_path: null From b672e28578e28786cfe4fbc019ae53bd8fc85c04 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sun, 9 Jul 2023 07:38:49 +0000 Subject: [PATCH 50/57] WIP setup h100 --- README.md | 16 +- RWKV-v4neo/src/model.py | 4 +- .../trainer-validation/baseline-setup.ipynb | 153 +- .../torch-compile-perf-a10g-ds2o.ipynb | 1747 ++++++++++++++++ .../torch-compile-perf-h100-ds1.ipynb | 1749 +++++++++++++++++ 5 files changed, 3588 insertions(+), 81 deletions(-) create mode 100644 notebook/trainer-validation/torch-compile-perf-a10g-ds2o.ipynb create mode 100644 notebook/trainer-validation/torch-compile-perf-h100-ds1.ipynb diff --git a/README.md b/README.md index ffb07044..e1c3e73a 100644 --- a/README.md +++ b/README.md @@ -38,16 +38,22 @@ sudo apt-get install ninja-build # Update conda & its package listings conda update conda -# Virtual env, with python 3.11 +# Virtual env, with python 3.10 +# python 3.11 have issues with torch.compile / h100s +# and if you want to use 3.11, you will need to do a nightly build install conda create -n rwkv-infctx python=3.11 pip conda activate rwkv-infctx # Install pytorch (>=2.0.1) -# conda install -y pytorch==2.0.1 torchvision==0.15.1 torchaudio==2.0.1 pytorch-cuda=11.8 -c pytorch -c nvidia +conda install -y pytorch==2.0.1 torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia -# Currently for torch.compile + 3.11 to work, we need the nightly 2.0.1 -# we expect this fix to be out in 2.0.2, and if so, use the previous line instead -conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch-nightly -c nvidia +# Currently for torch.compile + 3.11 to work, for some paltforms, you will need the nightly build +# if so you may need to try the following instead +# --- +# conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch-nightly -c nvidia + +# Verify your pytorch version +python -c "import torch; print(torch.__version__)" # We use python -m pip, instead of pip directly, as it resolve issues with venv not loading the right pip python -m pip install datasets transformers diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index 0e605925..a97d0d87 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -47,7 +47,7 @@ def is_torch_version_above(required_version): # We enable JITMod*/Function when supporting torch.jit # We use TorchCompile* when supporting torch compile # based on the current runtime settings -if RWKV_TORCH_COMPILE and torch._dynamo is not None: +if RWKV_TORCH_COMPILE: RWKV_TORCH_RUN_MODE = "torch-compile" JITModClass = nn.Module @@ -110,7 +110,7 @@ def is_torch_version_above(required_version): TCompileBaseline = lambda x: x TCompileDisable = lambda x: x -print(f"[RWKV.model] Running RWKV model via the following optimization mode : {RWKV_TORCH_RUN_MODE}") +print(f"[RWKV.model] Running RWKV model using '{RWKV_TORCH_RUN_MODE}' with torch '{torch.__version__}'") # --- # Isolating out known operations that **does not work** with torch.compile diff --git a/notebook/trainer-validation/baseline-setup.ipynb b/notebook/trainer-validation/baseline-setup.ipynb index 56a421db..c0025e73 100644 --- a/notebook/trainer-validation/baseline-setup.ipynb +++ b/notebook/trainer-validation/baseline-setup.ipynb @@ -25,7 +25,11 @@ { "attachments": {}, "cell_type": "markdown", - "metadata": {}, + "metadata": { + "notebookRunGroups": { + "groupValue": "" + } + }, "source": [ "## Preparing the init model and test dataset" ] @@ -39,21 +43,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2023-07-07 05:57:18-- https://huggingface.co/picocreator/memory-size-experiment-for-rwkv/resolve/main/Echo-A-1B5-Init.pth\n", - "Resolving huggingface.co (huggingface.co)... 99.84.108.70, 99.84.108.129, 99.84.108.87, ...\n", - "Connecting to huggingface.co (huggingface.co)|99.84.108.70|:443... connected.\n", + "--2023-07-09 05:50:16-- https://huggingface.co/picocreator/memory-size-experiment-for-rwkv/resolve/main/Echo-A-1B5-Init.pth\n", + "Resolving huggingface.co (huggingface.co)... 65.8.243.16, 65.8.243.46, 65.8.243.92, ...\n", + "Connecting to huggingface.co (huggingface.co)|65.8.243.16|:443... connected.\n", "HTTP request sent, awaiting response... 302 Found\n", - "Location: https://cdn-lfs.huggingface.co/repos/cb/ef/cbef09abb2634a3375b28868bffa285226dfeabedec89b28c2fb302221164d66/0ec7214ed16737a6348254e6f96d8cdc04d3b5efbd5f53fe9337607ea42b5b9f?response-content-disposition=attachment%3B+filename*%3DUTF-8%27%27Echo-A-1B5-Init.pth%3B+filename%3D%22Echo-A-1B5-Init.pth%22%3B&Expires=1688968638&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTY4ODk2ODYzOH19LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5odWdnaW5nZmFjZS5jby9yZXBvcy9jYi9lZi9jYmVmMDlhYmIyNjM0YTMzNzViMjg4NjhiZmZhMjg1MjI2ZGZlYWJlZGVjODliMjhjMmZiMzAyMjIxMTY0ZDY2LzBlYzcyMTRlZDE2NzM3YTYzNDgyNTRlNmY5NmQ4Y2RjMDRkM2I1ZWZiZDVmNTNmZTkzMzc2MDdlYTQyYjViOWY%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qIn1dfQ__&Signature=bWrBilBq61eOdD083qL6gaRBmu%7EeHdIZkOP2qm1guITML%7EkcnGNm%7EIVwoiSEDp-3Of%7EVz065FtfY8-DcCgLNdfnZ%7Ew36hly5DW%7E8CzcSlQLRR%7EQnG9j-ubmOeCemqlyecAMC7l%7E1sVus3RbMCkSo%7E6%7Eq8H%7EvnTbrgqydZmN%7E-XJ8l8mxAMCOCBH1yHmd2cmLz8kO8JPush23Zn4gHqo2vXluzR%7EAKe3a5IxlqZGmG7JIlB8ghYc0DjtSXqh5oGTB11qWxmGhlwBA5x3xbdHL3d4CACpx6HlwsQzQ7MC4czwAQqCmwTnaq3gZBF7TvaQc%7EQNU8JKD-tSX3C8uaaWYiw__&Key-Pair-Id=KVTP0A1DKRTAX [following]\n", - "--2023-07-07 05:57:18-- https://cdn-lfs.huggingface.co/repos/cb/ef/cbef09abb2634a3375b28868bffa285226dfeabedec89b28c2fb302221164d66/0ec7214ed16737a6348254e6f96d8cdc04d3b5efbd5f53fe9337607ea42b5b9f?response-content-disposition=attachment%3B+filename*%3DUTF-8%27%27Echo-A-1B5-Init.pth%3B+filename%3D%22Echo-A-1B5-Init.pth%22%3B&Expires=1688968638&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTY4ODk2ODYzOH19LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5odWdnaW5nZmFjZS5jby9yZXBvcy9jYi9lZi9jYmVmMDlhYmIyNjM0YTMzNzViMjg4NjhiZmZhMjg1MjI2ZGZlYWJlZGVjODliMjhjMmZiMzAyMjIxMTY0ZDY2LzBlYzcyMTRlZDE2NzM3YTYzNDgyNTRlNmY5NmQ4Y2RjMDRkM2I1ZWZiZDVmNTNmZTkzMzc2MDdlYTQyYjViOWY%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qIn1dfQ__&Signature=bWrBilBq61eOdD083qL6gaRBmu%7EeHdIZkOP2qm1guITML%7EkcnGNm%7EIVwoiSEDp-3Of%7EVz065FtfY8-DcCgLNdfnZ%7Ew36hly5DW%7E8CzcSlQLRR%7EQnG9j-ubmOeCemqlyecAMC7l%7E1sVus3RbMCkSo%7E6%7Eq8H%7EvnTbrgqydZmN%7E-XJ8l8mxAMCOCBH1yHmd2cmLz8kO8JPush23Zn4gHqo2vXluzR%7EAKe3a5IxlqZGmG7JIlB8ghYc0DjtSXqh5oGTB11qWxmGhlwBA5x3xbdHL3d4CACpx6HlwsQzQ7MC4czwAQqCmwTnaq3gZBF7TvaQc%7EQNU8JKD-tSX3C8uaaWYiw__&Key-Pair-Id=KVTP0A1DKRTAX\n", - "Resolving cdn-lfs.huggingface.co (cdn-lfs.huggingface.co)... 108.138.64.49, 108.138.64.36, 108.138.64.121, ...\n", - "Connecting to cdn-lfs.huggingface.co (cdn-lfs.huggingface.co)|108.138.64.49|:443... connected.\n", + "Location: https://cdn-lfs.huggingface.co/repos/cb/ef/cbef09abb2634a3375b28868bffa285226dfeabedec89b28c2fb302221164d66/0ec7214ed16737a6348254e6f96d8cdc04d3b5efbd5f53fe9337607ea42b5b9f?response-content-disposition=attachment%3B+filename*%3DUTF-8%27%27Echo-A-1B5-Init.pth%3B+filename%3D%22Echo-A-1B5-Init.pth%22%3B&Expires=1689141016&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTY4OTE0MTAxNn19LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5odWdnaW5nZmFjZS5jby9yZXBvcy9jYi9lZi9jYmVmMDlhYmIyNjM0YTMzNzViMjg4NjhiZmZhMjg1MjI2ZGZlYWJlZGVjODliMjhjMmZiMzAyMjIxMTY0ZDY2LzBlYzcyMTRlZDE2NzM3YTYzNDgyNTRlNmY5NmQ4Y2RjMDRkM2I1ZWZiZDVmNTNmZTkzMzc2MDdlYTQyYjViOWY%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qIn1dfQ__&Signature=iKAiomdiJ2ozlWxz4oPdqWyGJlQrT3tZ12ygG6zWwpGMfJMeAxomB%7EDh5malirVHqmvjSA-YLV1z0GAogkt91VTcKZCZQoFwYMLSDFFbGccGNKA5n8E6uzvbLe%7ESJNSe4ADiMy3--cyxtSITH2E6WbWFcX1k5nVWAFDAjDUr8wYE0FDH-tu--n-ZpFm1XQwhvVdow7jW0lGa-OJe-4orF2ZWJzE2c1-DGp-q0XvyD2jghe8rjy-FHhOdXHUj2jMK4AqomLUoVETw6skBooWwGuZL5S8Mr3UKKLh1CxqRykI3fyhhkhfM8Rb12XoBO1NADzAC27j0wabcCUppfGOQxg__&Key-Pair-Id=KVTP0A1DKRTAX [following]\n", + "--2023-07-09 05:50:17-- https://cdn-lfs.huggingface.co/repos/cb/ef/cbef09abb2634a3375b28868bffa285226dfeabedec89b28c2fb302221164d66/0ec7214ed16737a6348254e6f96d8cdc04d3b5efbd5f53fe9337607ea42b5b9f?response-content-disposition=attachment%3B+filename*%3DUTF-8%27%27Echo-A-1B5-Init.pth%3B+filename%3D%22Echo-A-1B5-Init.pth%22%3B&Expires=1689141016&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTY4OTE0MTAxNn19LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5odWdnaW5nZmFjZS5jby9yZXBvcy9jYi9lZi9jYmVmMDlhYmIyNjM0YTMzNzViMjg4NjhiZmZhMjg1MjI2ZGZlYWJlZGVjODliMjhjMmZiMzAyMjIxMTY0ZDY2LzBlYzcyMTRlZDE2NzM3YTYzNDgyNTRlNmY5NmQ4Y2RjMDRkM2I1ZWZiZDVmNTNmZTkzMzc2MDdlYTQyYjViOWY%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qIn1dfQ__&Signature=iKAiomdiJ2ozlWxz4oPdqWyGJlQrT3tZ12ygG6zWwpGMfJMeAxomB%7EDh5malirVHqmvjSA-YLV1z0GAogkt91VTcKZCZQoFwYMLSDFFbGccGNKA5n8E6uzvbLe%7ESJNSe4ADiMy3--cyxtSITH2E6WbWFcX1k5nVWAFDAjDUr8wYE0FDH-tu--n-ZpFm1XQwhvVdow7jW0lGa-OJe-4orF2ZWJzE2c1-DGp-q0XvyD2jghe8rjy-FHhOdXHUj2jMK4AqomLUoVETw6skBooWwGuZL5S8Mr3UKKLh1CxqRykI3fyhhkhfM8Rb12XoBO1NADzAC27j0wabcCUppfGOQxg__&Key-Pair-Id=KVTP0A1DKRTAX\n", + "Resolving cdn-lfs.huggingface.co (cdn-lfs.huggingface.co)... 18.160.143.2, 18.160.143.124, 18.160.143.47, ...\n", + "Connecting to cdn-lfs.huggingface.co (cdn-lfs.huggingface.co)|18.160.143.2|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 3030345861 (2.8G) [binary/octet-stream]\n", "Saving to: ‘Echo-A-1B5-Init.pth’\n", "\n", - "Echo-A-1B5-Init.pth 100%[===================>] 2.82G 60.9MB/s in 50s \n", + "Echo-A-1B5-Init.pth 100%[===================>] 2.82G 124MB/s in 24s \n", "\n", - "2023-07-07 05:58:09 (57.6 MB/s) - ‘Echo-A-1B5-Init.pth’ saved [3030345861/3030345861]\n", + "2023-07-09 05:50:41 (122 MB/s) - ‘Echo-A-1B5-Init.pth’ saved [3030345861/3030345861]\n", "\n", "-rw-rw-r-- 1 ubuntu ubuntu 2.9G Jun 22 04:41 ../../model/Echo-A-1B5-Init.pth\n" ] @@ -73,18 +77,27 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Found cached dataset parquet (/home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 986.66it/s]\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-3d43d1724bef83d7_*_of_00016.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-5033407f38c97f24.arrow\n", - "Loading cached processed dataset at /home/picocreator/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-78e7f3a5f1679aa4_*_of_00016.arrow\n", + "Downloading readme: 100%|███████████████████████| 424/424 [00:00<00:00, 287kB/s]\n", + "Downloading and preparing dataset None/None to /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7...\n", + "Downloading data files: 0%| | 0/1 [00:00\n", + " cli_main()\n", + " File \"/home/ubuntu/dev-infctx-torch-compile/RWKV-v4neo/new_train.py\", line 8, in cli_main\n", + " LightningCLI(\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/pytorch/cli.py\", line 350, in __init__\n", + " self.instantiate_classes()\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/pytorch/cli.py\", line 499, in instantiate_classes\n", + " self.config_init = self.parser.instantiate_classes(self.config)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/jsonargparse/_deprecated.py\", line 139, in patched_instantiate_classes\n", + " cfg = self._unpatched_instantiate_classes(cfg, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/jsonargparse/_core.py\", line 1128, in instantiate_classes\n", + " cfg[subcommand] = subparser.instantiate_classes(cfg[subcommand], instantiate_groups=instantiate_groups)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/jsonargparse/_deprecated.py\", line 139, in patched_instantiate_classes\n", + " cfg = self._unpatched_instantiate_classes(cfg, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/jsonargparse/_core.py\", line 1122, in instantiate_classes\n", + " component.instantiate_class(component, cfg)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/jsonargparse/_signatures.py\", line 558, in group_instantiate_class\n", + " parent[key] = group.group_class(**value)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/dev-infctx-torch-compile/RWKV-v4neo/src/model.py\", line 452, in __init__\n", + " self.load_state_dict(torch.load(load_model, map_location='cpu'))\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/serialization.py\", line 1016, in load\n", + " return _load(opened_zipfile,\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/serialization.py\", line 1424, in _load\n", + " result = unpickler.load()\n", + " ^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/pickle.py\", line 1213, in load\n", + " dispatch[key[0]](self)\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/pickle.py\", line 1254, in load_binpersid\n", + " self.append(self.persistent_load(pid))\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/serialization.py\", line 1394, in persistent_load\n", + " typed_storage = load_tensor(dtype, nbytes, key, _maybe_decode_ascii(location))\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/torch/serialization.py\", line 1359, in load_tensor\n", + " storage = zip_file.get_storage_from_record(name, numel, torch.UntypedStorage)._typed_storage()._untyped_storage\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n" ] } ], diff --git a/notebook/trainer-validation/torch-compile-perf-a10g-ds2o.ipynb b/notebook/trainer-validation/torch-compile-perf-a10g-ds2o.ipynb new file mode 100644 index 00000000..cd1e856d --- /dev/null +++ b/notebook/trainer-validation/torch-compile-perf-a10g-ds2o.ipynb @@ -0,0 +1,1747 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# torch.compile performance uplift validation\n", + "The following trainer validation, is used to compare performance differences between the following optimizations\n", + "\n", + "- torch native\n", + "- torch + JIT\n", + "- torch + torch.compile\n", + "\n", + "It presumes that basic setup has been done as per\n", + "- `./baseline-setup.ipynb`\n", + "\n", + "To simplify the benchmarking, we are intentionally only performing\n", + "- training & data ctx len fixed at 4096\n", + "- a 100 trainer/global_step\n", + "- of 10 gradient accumulation (per GPU)\n", + "- no checkpoint save to disk (reduce the influence of random diskio in timings)\n", + "\n", + "This would (on a single GPU) perform the run over\n", + "- a 1000 data samples\n", + "\n", + "\n", + "The following experiments were executed on a single `a10g` gpu `g5.8xlarge` AWS instance for consistency. With `deepspeed_stage_2_offload`" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install the nightly build within conda\n", + "(Skip if you already have 2.1.0, or already done the setup)\n", + "\n", + "For torch.compile, as of 8th July 2023, you will need the torch nightly build for several fixes we depend on. This is expected to be resolved when merged in for torch 2.1.0 release (you will need to perform this setup outside the notebook)\n", + "\n", + "```bash\n", + "conda activate rwkv-infctx\n", + "conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch-nightly -c nvidia\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configure and apply your preferred settings\n", + "\n", + "Adjust your desired deepspeed settings, and gpu device count.\n", + "Enable/Disable WANDB here as well (recommended disabled, to reduce perf impact)\n", + "\n", + "( note you will need to rerun this cell, if you restart your env )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DEEPSPEED_STRAT: deepspeed_stage_2_offload\n", + "ENABLE_WANDB: False\n", + "GPU_DEVICES: auto\n" + ] + } + ], + "source": [ + "DEEPSPEED_STRAT=\"deepspeed_stage_2_offload\"\n", + "GPU_DEVICES=\"auto\"\n", + "ENABLE_WANDB=False\n", + "\n", + "print(\"DEEPSPEED_STRAT:\", DEEPSPEED_STRAT)\n", + "print(\"ENABLE_WANDB:\", ENABLE_WANDB)\n", + "print(\"GPU_DEVICES:\", GPU_DEVICES)\n", + "\n", + "if ENABLE_WANDB:\n", + " WANDB_MODE=\"online\"\n", + "else:\n", + " WANDB_MODE=\"disabled\"\n", + "\n", + "# Ensure logs dir is initialized\n", + "!mkdir -p \"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preload your data\n", + "The data has minor differences from baseline, and needs to be preloaded here" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 977.69it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-0b77c6df8d77d6b6_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f32adc0b9b83547d_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-9a2bc99bc09b7d14_*_of_00032.arrow\n", + " \r" + ] + } + ], + "source": [ + "!cd ../../RWKV-v4neo && python3 preload_dataset.py ../notebook/trainer-validation/config/torch-compile-perf.yaml" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Perform baseline benchmark (no JIT / no toch compile)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-07-08 17:51:59,139] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[RWKV.model] Running RWKV model via the following optimization mode : torch-native\n", + "Global seed set to 3941088705\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_4096_bf16/build.ninja...\n", + "Building extension module wkv_4096_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module wkv_4096_bf16...\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 945.09it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-0b77c6df8d77d6b6_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f32adc0b9b83547d_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-9a2bc99bc09b7d14_*_of_00032.arrow\n", + "[rank: 0] Global seed set to 3941088705 \n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[2023-07-08 17:52:12,529] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-08 17:52:12,530] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "Enabling DeepSpeed BF16.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096)\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module cpu_adam...\n", + "Time to load cpu_adam op: 2.326359748840332 seconds\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "Epoch 0: 0%| | 0/1315 [00:00=1.0.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.1.0)\n", + "Requirement already satisfied: cycler>=0.10 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (0.11.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (4.40.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.4.4)\n", + "Requirement already satisfied: numpy>=1.20 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.25.0)\n", + "Requirement already satisfied: packaging>=20.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (22.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (9.3.0)\n", + "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: six>=1.5 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n" + ] + } + ], + "source": [ + "# Install matlab plotting library\n", + "!python3 -m pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First step figures ...\n", + "Baseline: {'it': 1, 'time': 9, 's_time': '00:09', 'loss': 10.9}\n", + "JIT: {'it': 1, 'time': 13, 's_time': '00:13', 'loss': 10.9}\n", + "Torch Compile: {'it': 1, 'time': 72, 's_time': '01:12', 'loss': 10.9}\n", + "\n", + "First 200 step figures ...\n", + "Baseline: {'it': 101, 'time': 175, 's_time': '02:55', 'loss': 8.38}\n", + "JIT: {'it': 101, 'time': 172, 's_time': '02:52', 'loss': 8.38}\n", + "Torch Compile: {'it': 101, 'time': 225, 's_time': '03:45', 'loss': 8.38}\n", + "\n", + "Last step figures ...\n", + "Baseline: {'it': 1000, 'time': 1464, 's_time': '24:24', 'loss': 6.62}\n", + "JIT: {'it': 1000, 'time': 1407, 's_time': '23:27', 'loss': 6.66}\n", + "Torch Compile: {'it': 1000, 'time': 1399, 's_time': '23:19', 'loss': 6.66}\n" + ] + } + ], + "source": [ + "# First we need to extract the numbers from the logs\n", + "import re\n", + "\n", + "def convert_time_to_seconds(time_str):\n", + " t = list(map(int, time_str.split(':')))\n", + " return sum([a*b for (a,b) in zip(t[::-1], (1, 60, 3600))])\n", + "\n", + "def extract_from_training_logs(log_file):\n", + " result = []\n", + " with open(log_file, 'r') as file:\n", + " for line in file.readlines():\n", + " # Check if the line starts with \"Epoch 0:\"\n", + " if line.startswith(\"Epoch 0:\"):\n", + " iteration = re.search(r'(?<=\\| )(\\d+)', line) # Extracts the iteration number\n", + " time_spent = re.search(r'(?<=\\[)(.*?)(?=<)', line) # Extracts the time spent so far\n", + " loss = re.search(r'(?<=train/loss=)(\\d+.\\d+)', line) # Extracts the train/loss number\n", + " \n", + " if iteration and time_spent and loss:\n", + " result.append({\n", + " \"it\": int(iteration.group(0)), \n", + " \"time\": convert_time_to_seconds(time_spent.group(0)),\n", + " \"s_time\": time_spent.group(0),\n", + " \"loss\": float(loss.group(0))\n", + " })\n", + " return result\n", + "\n", + "\n", + "# Extract the numbers\n", + "step_baseline = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/baseline.log\")\n", + "step_jit = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/jit.log\")\n", + "step_tcompile = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/torch-compile.log\")\n", + "\n", + "# Print the high level numbers (quick debugging, if log has issues)\n", + "print(\"First step figures ...\")\n", + "print(\"Baseline: \", step_baseline[0])\n", + "print(\"JIT: \", step_jit[0])\n", + "print(\"Torch Compile: \", step_tcompile[0])\n", + "print(\"\")\n", + "print(\"First 200 step figures ...\")\n", + "print(\"Baseline: \", step_baseline[200])\n", + "print(\"JIT: \", step_jit[200])\n", + "print(\"Torch Compile: \", step_tcompile[200])\n", + "print(\"\")\n", + "print(\"Last step figures ...\")\n", + "print(\"Baseline: \", step_baseline[-1])\n", + "print(\"JIT: \", step_jit[-1])\n", + "print(\"Torch Compile: \", step_tcompile[-1])\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Check if the loss plot is similar\n", + "\n", + "No point having a faster JIT / torch.compile, if the loss curve does not fall at the same rate" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the loss curve\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Extract iteration and loss values for each method\n", + "it_baseline = [entry['it'] for entry in step_baseline]\n", + "loss_baseline = [entry['loss'] for entry in step_baseline]\n", + "\n", + "it_jit = [entry['it'] for entry in step_jit]\n", + "loss_jit = [entry['loss'] for entry in step_jit]\n", + "\n", + "it_tcompile = [entry['it'] for entry in step_tcompile]\n", + "loss_tcompile = [entry['loss'] for entry in step_tcompile]\n", + "\n", + "# Plot loss curves\n", + "plt.plot(it_baseline, loss_baseline, label=\"Baseline\", linestyle='-')\n", + "plt.plot(it_jit, loss_jit, label=\"JIT\", linestyle='--')\n", + "plt.plot(it_tcompile, loss_tcompile, label=\"TCompile\", linestyle='-.')\n", + "\n", + "plt.xlabel('Iteration step')\n", + "plt.ylabel('Loss')\n", + "plt.title('Loss Curve')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working as designed, it should be nearly impossible to see the differences between the 3 lines. So lets plot the delta against baseline instead." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Convert lists to numpy arrays for easier manipulation\n", + "loss_baseline_np = np.array(loss_baseline)\n", + "loss_jit_np = np.array(loss_jit)\n", + "loss_tcompile_np = np.array(loss_tcompile)\n", + "\n", + "# Calculate deltas\n", + "delta_jit_baseline = (loss_jit_np - loss_baseline_np)\n", + "delta_tcompile_baseline = (loss_tcompile_np - loss_baseline_np)\n", + "\n", + "# Plot deltas\n", + "plt.plot(it_jit, delta_jit_baseline, label=\"JIT - Baseline\", linestyle='-', color='blue', alpha=0.6)\n", + "plt.plot(it_tcompile, delta_tcompile_baseline, label=\"TCompile - Baseline\", linestyle='--', color='red', alpha=0.6)\n", + "\n", + "plt.xlabel('Iteration step')\n", + "plt.ylabel('Delta Loss')\n", + "plt.title('Delta Loss Curve (compared to Baseline)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working as per designed, the differences between \"Delta Loss\" should be within margin of error, of run-by-run varience" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot the time charts!\n", + "\n", + "Lets start with a basic iteration step over cummulative time" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Extract the 'it' and 'time' values from each dictionary in each list\n", + "it_baseline = [x['it'] for x in step_baseline]\n", + "time_baseline = [x['time'] for x in step_baseline]\n", + "\n", + "it_jit = [x['it'] for x in step_jit]\n", + "time_jit = [x['time'] for x in step_jit]\n", + "\n", + "it_tcompile = [x['it'] for x in step_tcompile]\n", + "time_tcompile = [x['time'] for x in step_tcompile]\n", + "\n", + "# Plot cumulative time for each iteration\n", + "plt.plot(it_baseline, time_baseline, label='Baseline')\n", + "plt.plot(it_jit, time_jit, label='Jit')\n", + "plt.plot(it_tcompile, time_tcompile, label='TCompile')\n", + "\n", + "# Label the axes\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Cumulative Time')\n", + "\n", + "# Add a legend\n", + "plt.legend(loc='upper left')\n", + "\n", + "# Display the plot\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working correctly it should show that\n", + "\n", + "- baseline: lowest starting time, highest accumulative rate\n", + "- JIT: similar starting time, lower accumulative rate\n", + "- TCompile: slowest starting time, lowest accumulative rate\n", + "\n", + "This can be observed by getting the average time per iteration for the first 200 steps and the following 2 x 400 steps" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average delta time for the first 200 iterations ('warmup'):\n", + "Baseline: 875.0 ms\n", + "Jit: 860.0 ms\n", + "TCompile: 1125.0 ms\n", + "\n", + "Average delta time after 'warmup' for 400 iterations:\n", + "Baseline: 715.0 ms\n", + "Jit: 685.0 ms\n", + "TCompile: 652.5 ms\n", + "\n", + "Average delta time for last 400 iterations:\n", + "Baseline: 717.5 ms\n", + "Jit: 687.5 ms\n", + "TCompile: 655.0 ms\n" + ] + } + ], + "source": [ + "# Compute the average time for the first `n` iterations and for the rest\n", + "def compute_average_time_delta(data, start, end):\n", + " time = [x['time'] for x in data]\n", + " if start == -1:\n", + " return (time[end-1]) / (end)\n", + " else:\n", + " return (time[end-1] - time[start]) / (end - start)\n", + "\n", + "# PS, [0] pos shows the timing for the first step, so we use -1 to start from \"0\"\n", + "first_R = 200\n", + "first_R_baseline = compute_average_time_delta(step_baseline, -1, first_R)\n", + "first_R_jit = compute_average_time_delta(step_jit, -1, first_R)\n", + "first_R_tcompile = compute_average_time_delta(step_tcompile, -1, first_R)\n", + "\n", + "next_W = 400\n", + "next_W_baseline = compute_average_time_delta(step_baseline, first_R, first_R + next_W)\n", + "next_W_jit = compute_average_time_delta(step_jit, first_R, first_R + next_W)\n", + "next_W_tcompile = compute_average_time_delta(step_tcompile, first_R, first_R + next_W)\n", + "\n", + "next_K = 400\n", + "next_K_baseline = compute_average_time_delta(step_baseline, first_R + next_W, first_R + next_W + next_K)\n", + "next_K_jit = compute_average_time_delta(step_jit, first_R + next_W, first_R + next_W + next_K)\n", + "next_K_tcompile = compute_average_time_delta(step_tcompile, first_R + next_W, first_R + next_W + next_K)\n", + "\n", + "print(f\"Average delta time for the first {first_R} iterations ('warmup'):\")\n", + "print(f\"Baseline: {first_R_baseline * 1000} ms\")\n", + "print(f\"Jit: {first_R_jit * 1000} ms\")\n", + "print(f\"TCompile: {first_R_tcompile * 1000} ms\")\n", + "print(\"\")\n", + "\n", + "print(f\"Average delta time after 'warmup' for {next_W} iterations:\")\n", + "print(f\"Baseline: {next_W_baseline * 1000} ms\")\n", + "print(f\"Jit: {next_W_jit * 1000} ms\")\n", + "print(f\"TCompile: {next_W_tcompile * 1000} ms\")\n", + "print(\"\")\n", + "\n", + "print(f\"Average delta time for last {next_K} iterations:\")\n", + "print(f\"Baseline: {next_K_baseline * 1000} ms\")\n", + "print(f\"Jit: {next_K_jit * 1000} ms\")\n", + "print(f\"TCompile: {next_K_tcompile * 1000} ms\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "rwkv-infctx", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebook/trainer-validation/torch-compile-perf-h100-ds1.ipynb b/notebook/trainer-validation/torch-compile-perf-h100-ds1.ipynb new file mode 100644 index 00000000..d6e1fc98 --- /dev/null +++ b/notebook/trainer-validation/torch-compile-perf-h100-ds1.ipynb @@ -0,0 +1,1749 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# torch.compile performance uplift validation\n", + "The following trainer validation, is used to compare performance differences between the following optimizations\n", + "\n", + "- torch native\n", + "- torch + JIT\n", + "- torch + torch.compile\n", + "\n", + "It presumes that basic setup has been done as per\n", + "- `./baseline-setup.ipynb`\n", + "\n", + "To simplify the benchmarking, we are intentionally only performing\n", + "- training & data ctx len fixed at 4096\n", + "- a 100 trainer/global_step\n", + "- of 10 gradient accumulation (per GPU)\n", + "- no checkpoint save to disk (reduce the influence of random diskio in timings)\n", + "\n", + "This would (on a single GPU) perform the run over\n", + "- a 1000 data samples\n", + "\n", + "The following experiments were executed on a single `h100` via `lambdalabs`" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install the nightly build within conda\n", + "(Skip if you already have 2.1.0, or already done the setup)\n", + "\n", + "For torch.compile, as of 8th July 2023, you will need the torch nightly build for several fixes we depend on. This is expected to be resolved when merged in for torch 2.1.0 release (you will need to perform this setup outside the notebook)\n", + "\n", + "```bash\n", + "conda activate rwkv-infctx\n", + "conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch-nightly -c nvidia\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configure and apply your preferred settings\n", + "\n", + "Adjust your desired deepspeed settings, and gpu device count.\n", + "Enable/Disable WANDB here as well (recommended disabled, to reduce perf impact)\n", + "\n", + "( note you will need to rerun this cell, if you restart your env )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DEEPSPEED_STRAT: deepspeed_stage_1\n", + "ENABLE_WANDB: False\n", + "GPU_DEVICES: auto\n" + ] + } + ], + "source": [ + "DEEPSPEED_STRAT=\"deepspeed_stage_1\"\n", + "GPU_DEVICES=\"auto\"\n", + "ENABLE_WANDB=False\n", + "\n", + "print(\"DEEPSPEED_STRAT:\", DEEPSPEED_STRAT)\n", + "print(\"ENABLE_WANDB:\", ENABLE_WANDB)\n", + "print(\"GPU_DEVICES:\", GPU_DEVICES)\n", + "\n", + "if ENABLE_WANDB:\n", + " WANDB_MODE=\"online\"\n", + "else:\n", + " WANDB_MODE=\"disabled\"\n", + "\n", + "# Ensure logs dir is initialized\n", + "!mkdir -p \"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/\"\n", + "\n", + "# Log the python version\n", + "!python --version" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preload your data\n", + "The data has minor differences from baseline, and needs to be preloaded here" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 977.69it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-0b77c6df8d77d6b6_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f32adc0b9b83547d_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-9a2bc99bc09b7d14_*_of_00032.arrow\n", + " \r" + ] + } + ], + "source": [ + "!cd ../../RWKV-v4neo && python3 preload_dataset.py ../notebook/trainer-validation/config/torch-compile-perf.yaml" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Perform baseline benchmark (no JIT / no toch compile)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2023-07-08 17:51:59,139] [INFO] [real_accelerator.py:110:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n", + "[RWKV.model] Running RWKV model via the following optimization mode : torch-native\n", + "Global seed set to 3941088705\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/wkv_4096_bf16/build.ninja...\n", + "Building extension module wkv_4096_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module wkv_4096_bf16...\n", + "/home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages/lightning/fabric/connector.py:555: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "Found cached dataset parquet (/home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 945.09it/s]\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-0b77c6df8d77d6b6_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-f32adc0b9b83547d_*_of_00032.arrow\n", + "Loading cached processed dataset at /home/ubuntu/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-9a2bc99bc09b7d14_*_of_00032.arrow\n", + "[rank: 0] Global seed set to 3941088705 \n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/1\n", + "[2023-07-08 17:52:12,529] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-08 17:52:12,530] [WARNING] [deepspeed.py:638:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "Enabling DeepSpeed BF16.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "[WARNING]: it is highly recommended to enable bptt_learning when used to deepspeed 2/3/offloading, otherwise an exception will occur when training with dataset records, larger then the configured context length (4096)\n", + "Using /home/ubuntu/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /home/ubuntu/.cache/torch_extensions/py311_cu118/cpu_adam/build.ninja...\n", + "Building extension module cpu_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module cpu_adam...\n", + "Time to load cpu_adam op: 2.326359748840332 seconds\n", + "Rank: 0 partition count [1, 1, 1] and sizes[(1515008000, False), (49152, False), (49152, False)] \n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "Epoch 0: 0%| | 0/1315 [00:00=1.0.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.1.0)\n", + "Requirement already satisfied: cycler>=0.10 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (0.11.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (4.40.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.4.4)\n", + "Requirement already satisfied: numpy>=1.20 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.25.0)\n", + "Requirement already satisfied: packaging>=20.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (22.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (9.3.0)\n", + "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: six>=1.5 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n" + ] + } + ], + "source": [ + "# Install matlab plotting library\n", + "!python3 -m pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First step figures ...\n", + "Baseline: {'it': 1, 'time': 9, 's_time': '00:09', 'loss': 10.9}\n", + "JIT: {'it': 1, 'time': 13, 's_time': '00:13', 'loss': 10.9}\n", + "Torch Compile: {'it': 1, 'time': 72, 's_time': '01:12', 'loss': 10.9}\n", + "\n", + "First 200 step figures ...\n", + "Baseline: {'it': 101, 'time': 175, 's_time': '02:55', 'loss': 8.38}\n", + "JIT: {'it': 101, 'time': 172, 's_time': '02:52', 'loss': 8.38}\n", + "Torch Compile: {'it': 101, 'time': 225, 's_time': '03:45', 'loss': 8.38}\n", + "\n", + "Last step figures ...\n", + "Baseline: {'it': 1000, 'time': 1464, 's_time': '24:24', 'loss': 6.62}\n", + "JIT: {'it': 1000, 'time': 1407, 's_time': '23:27', 'loss': 6.66}\n", + "Torch Compile: {'it': 1000, 'time': 1399, 's_time': '23:19', 'loss': 6.66}\n" + ] + } + ], + "source": [ + "# First we need to extract the numbers from the logs\n", + "import re\n", + "\n", + "def convert_time_to_seconds(time_str):\n", + " t = list(map(int, time_str.split(':')))\n", + " return sum([a*b for (a,b) in zip(t[::-1], (1, 60, 3600))])\n", + "\n", + "def extract_from_training_logs(log_file):\n", + " result = []\n", + " with open(log_file, 'r') as file:\n", + " for line in file.readlines():\n", + " # Check if the line starts with \"Epoch 0:\"\n", + " if line.startswith(\"Epoch 0:\"):\n", + " iteration = re.search(r'(?<=\\| )(\\d+)', line) # Extracts the iteration number\n", + " time_spent = re.search(r'(?<=\\[)(.*?)(?=<)', line) # Extracts the time spent so far\n", + " loss = re.search(r'(?<=train/loss=)(\\d+.\\d+)', line) # Extracts the train/loss number\n", + " \n", + " if iteration and time_spent and loss:\n", + " result.append({\n", + " \"it\": int(iteration.group(0)), \n", + " \"time\": convert_time_to_seconds(time_spent.group(0)),\n", + " \"s_time\": time_spent.group(0),\n", + " \"loss\": float(loss.group(0))\n", + " })\n", + " return result\n", + "\n", + "\n", + "# Extract the numbers\n", + "step_baseline = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/baseline.log\")\n", + "step_jit = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/jit.log\")\n", + "step_tcompile = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/torch-compile.log\")\n", + "\n", + "# Print the high level numbers (quick debugging, if log has issues)\n", + "print(\"First step figures ...\")\n", + "print(\"Baseline: \", step_baseline[0])\n", + "print(\"JIT: \", step_jit[0])\n", + "print(\"Torch Compile: \", step_tcompile[0])\n", + "print(\"\")\n", + "print(\"First 200 step figures ...\")\n", + "print(\"Baseline: \", step_baseline[200])\n", + "print(\"JIT: \", step_jit[200])\n", + "print(\"Torch Compile: \", step_tcompile[200])\n", + "print(\"\")\n", + "print(\"Last step figures ...\")\n", + "print(\"Baseline: \", step_baseline[-1])\n", + "print(\"JIT: \", step_jit[-1])\n", + "print(\"Torch Compile: \", step_tcompile[-1])\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Check if the loss plot is similar\n", + "\n", + "No point having a faster JIT / torch.compile, if the loss curve does not fall at the same rate" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the loss curve\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Extract iteration and loss values for each method\n", + "it_baseline = [entry['it'] for entry in step_baseline]\n", + "loss_baseline = [entry['loss'] for entry in step_baseline]\n", + "\n", + "it_jit = [entry['it'] for entry in step_jit]\n", + "loss_jit = [entry['loss'] for entry in step_jit]\n", + "\n", + "it_tcompile = [entry['it'] for entry in step_tcompile]\n", + "loss_tcompile = [entry['loss'] for entry in step_tcompile]\n", + "\n", + "# Plot loss curves\n", + "plt.plot(it_baseline, loss_baseline, label=\"Baseline\", linestyle='-')\n", + "plt.plot(it_jit, loss_jit, label=\"JIT\", linestyle='--')\n", + "plt.plot(it_tcompile, loss_tcompile, label=\"TCompile\", linestyle='-.')\n", + "\n", + "plt.xlabel('Iteration step')\n", + "plt.ylabel('Loss')\n", + "plt.title('Loss Curve')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working as designed, it should be nearly impossible to see the differences between the 3 lines. So lets plot the delta against baseline instead." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Convert lists to numpy arrays for easier manipulation\n", + "loss_baseline_np = np.array(loss_baseline)\n", + "loss_jit_np = np.array(loss_jit)\n", + "loss_tcompile_np = np.array(loss_tcompile)\n", + "\n", + "# Calculate deltas\n", + "delta_jit_baseline = (loss_jit_np - loss_baseline_np)\n", + "delta_tcompile_baseline = (loss_tcompile_np - loss_baseline_np)\n", + "\n", + "# Plot deltas\n", + "plt.plot(it_jit, delta_jit_baseline, label=\"JIT - Baseline\", linestyle='-', color='blue', alpha=0.6)\n", + "plt.plot(it_tcompile, delta_tcompile_baseline, label=\"TCompile - Baseline\", linestyle='--', color='red', alpha=0.6)\n", + "\n", + "plt.xlabel('Iteration step')\n", + "plt.ylabel('Delta Loss')\n", + "plt.title('Delta Loss Curve (compared to Baseline)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working as per designed, the differences between \"Delta Loss\" should be within margin of error, of run-by-run varience" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot the time charts!\n", + "\n", + "Lets start with a basic iteration step over cummulative time" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Extract the 'it' and 'time' values from each dictionary in each list\n", + "it_baseline = [x['it'] for x in step_baseline]\n", + "time_baseline = [x['time'] for x in step_baseline]\n", + "\n", + "it_jit = [x['it'] for x in step_jit]\n", + "time_jit = [x['time'] for x in step_jit]\n", + "\n", + "it_tcompile = [x['it'] for x in step_tcompile]\n", + "time_tcompile = [x['time'] for x in step_tcompile]\n", + "\n", + "# Plot cumulative time for each iteration\n", + "plt.plot(it_baseline, time_baseline, label='Baseline')\n", + "plt.plot(it_jit, time_jit, label='Jit')\n", + "plt.plot(it_tcompile, time_tcompile, label='TCompile')\n", + "\n", + "# Label the axes\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Cumulative Time')\n", + "\n", + "# Add a legend\n", + "plt.legend(loc='upper left')\n", + "\n", + "# Display the plot\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If everything is working correctly it should show that\n", + "\n", + "- baseline: lowest starting time, highest accumulative rate\n", + "- JIT: similar starting time, lower accumulative rate\n", + "- TCompile: slowest starting time, lowest accumulative rate\n", + "\n", + "This can be observed by getting the average time per iteration for the first 200 steps and the following 2 x 400 steps" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average delta time for the first 200 iterations ('warmup'):\n", + "Baseline: 875.0 ms\n", + "Jit: 860.0 ms\n", + "TCompile: 1125.0 ms\n", + "\n", + "Average delta time after 'warmup' for 400 iterations:\n", + "Baseline: 715.0 ms\n", + "Jit: 685.0 ms\n", + "TCompile: 652.5 ms\n", + "\n", + "Average delta time for last 400 iterations:\n", + "Baseline: 717.5 ms\n", + "Jit: 687.5 ms\n", + "TCompile: 655.0 ms\n" + ] + } + ], + "source": [ + "# Compute the average time for the first `n` iterations and for the rest\n", + "def compute_average_time_delta(data, start, end):\n", + " time = [x['time'] for x in data]\n", + " if start == -1:\n", + " return (time[end-1]) / (end)\n", + " else:\n", + " return (time[end-1] - time[start]) / (end - start)\n", + "\n", + "# PS, [0] pos shows the timing for the first step, so we use -1 to start from \"0\"\n", + "first_R = 200\n", + "first_R_baseline = compute_average_time_delta(step_baseline, -1, first_R)\n", + "first_R_jit = compute_average_time_delta(step_jit, -1, first_R)\n", + "first_R_tcompile = compute_average_time_delta(step_tcompile, -1, first_R)\n", + "\n", + "next_W = 400\n", + "next_W_baseline = compute_average_time_delta(step_baseline, first_R, first_R + next_W)\n", + "next_W_jit = compute_average_time_delta(step_jit, first_R, first_R + next_W)\n", + "next_W_tcompile = compute_average_time_delta(step_tcompile, first_R, first_R + next_W)\n", + "\n", + "next_K = 400\n", + "next_K_baseline = compute_average_time_delta(step_baseline, first_R + next_W, first_R + next_W + next_K)\n", + "next_K_jit = compute_average_time_delta(step_jit, first_R + next_W, first_R + next_W + next_K)\n", + "next_K_tcompile = compute_average_time_delta(step_tcompile, first_R + next_W, first_R + next_W + next_K)\n", + "\n", + "print(f\"Average delta time for the first {first_R} iterations ('warmup'):\")\n", + "print(f\"Baseline: {first_R_baseline * 1000} ms\")\n", + "print(f\"Jit: {first_R_jit * 1000} ms\")\n", + "print(f\"TCompile: {first_R_tcompile * 1000} ms\")\n", + "print(\"\")\n", + "\n", + "print(f\"Average delta time after 'warmup' for {next_W} iterations:\")\n", + "print(f\"Baseline: {next_W_baseline * 1000} ms\")\n", + "print(f\"Jit: {next_W_jit * 1000} ms\")\n", + "print(f\"TCompile: {next_W_tcompile * 1000} ms\")\n", + "print(\"\")\n", + "\n", + "print(f\"Average delta time for last {next_K} iterations:\")\n", + "print(f\"Baseline: {next_K_baseline * 1000} ms\")\n", + "print(f\"Jit: {next_K_jit * 1000} ms\")\n", + "print(f\"TCompile: {next_K_tcompile * 1000} ms\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "rwkv-infctx", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From e3de0dffc449ad21ba19f177d0b2602152e83c60 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Sun, 9 Jul 2023 09:22:22 +0000 Subject: [PATCH 51/57] deepspeed 2 & 3 validation runs --- .../deepspeed-2-and-3.ipynb | 184 ++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100644 notebook/trainer-validation/deepspeed-2-and-3.ipynb diff --git a/notebook/trainer-validation/deepspeed-2-and-3.ipynb b/notebook/trainer-validation/deepspeed-2-and-3.ipynb new file mode 100644 index 00000000..81640d03 --- /dev/null +++ b/notebook/trainer-validation/deepspeed-2-and-3.ipynb @@ -0,0 +1,184 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deepspeed 2 & Validation\n", + "This model being trained has the same settings as raven 1B5 model.\n", + "- Layer count: 24\n", + "- Embed size: 2048\n", + "\n", + "The goal is to validate the trainer across deepspeed 2 & 3 - with and without offload. All other training params remain constant.\n", + "\n", + "Note, you will need a dual+ GPU setup, that is capable of handling deepspeed 2\n", + "\n", + "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps\n", + ">\n", + "> And that you have completed the `baseline-setup.ipynb`" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configure and apply your preferred settings\n", + "\n", + "Adjust your desired deepspeed settings, and gpu device count.\n", + "\n", + "Enable/Disable WANDB here as well ( Enabled by default, as we need the loss curve for this experiment )\n", + "\n", + "( note you will need to rerun this cell, if you restart your env )" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DEEPSPEED_STRAT: deepspeed_stage_2_offload\n", + "ENABLE_WANDB: True\n", + "GPU_DEVICES: auto\n" + ] + } + ], + "source": [ + "GPU_DEVICES=\"auto\"\n", + "ENABLE_WANDB=True\n", + "WANDB_PREFIX=\"infctx-deepspeed\"\n", + "\n", + "print(\"ENABLE_WANDB:\", ENABLE_WANDB)\n", + "print(\"GPU_DEVICES:\", GPU_DEVICES)\n", + "\n", + "if ENABLE_WANDB:\n", + " WANDB_MODE=\"online\"\n", + "else:\n", + " WANDB_MODE=\"disabled\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deepspeed 2\n", + "Perform a full 1 epoch training run of training context size = 1024. With deepspeed 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!cd ../../RWKV-v4neo && \\\n", + " export WANDB_MODE=\"{WANDB_MODE}\" && \\\n", + " python3 new_train.py fit \\\n", + " -c ../notebook/trainer-validation/config/baseline-1024.yaml \\\n", + " --trainer.logger.init_args.name=\"{WANDB_PREFIX} (deepspeed_stage_2, train-ctx=1024, data-ctx=1024)\" \\\n", + " --trainer.strategy=\"deepspeed_stage_2\" \\\n", + " --trainer.devices=\"{GPU_DEVICES}\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deepspeed 2 + Offload\n", + "Perform a full 1 epoch training run of training context size = 1024. With deepspeed 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!cd ../../RWKV-v4neo && \\\n", + " export WANDB_MODE=\"{WANDB_MODE}\" && \\\n", + " python3 new_train.py fit \\\n", + " -c ../notebook/trainer-validation/config/baseline-1024.yaml \\\n", + " --trainer.logger.init_args.name=\"{WANDB_PREFIX} (deepspeed_stage_2_offload, train-ctx=1024, data-ctx=1024)\" \\\n", + " --trainer.strategy=\"deepspeed_stage_2_offload\" \\\n", + " --trainer.devices=\"{GPU_DEVICES}\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deepspeed 3\n", + "Perform a full 1 epoch training run of training context size = 1024. With deepspeed 3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!cd ../../RWKV-v4neo && \\\n", + " export WANDB_MODE=\"{WANDB_MODE}\" && \\\n", + " python3 new_train.py fit \\\n", + " -c ../notebook/trainer-validation/config/baseline-1024.yaml \\\n", + " --trainer.logger.init_args.name=\"{WANDB_PREFIX} (deepspeed_stage_3, train-ctx=1024, data-ctx=1024)\" \\\n", + " --trainer.strategy=\"deepspeed_stage_3\" \\\n", + " --trainer.devices=\"{GPU_DEVICES}\"" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deepspeed 3 + offload\n", + "Perform a full 1 epoch training run of training context size = 1024. With deepspeed 3 + offload" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!cd ../../RWKV-v4neo && \\\n", + " export WANDB_MODE=\"{WANDB_MODE}\" && \\\n", + " python3 new_train.py fit \\\n", + " -c ../notebook/trainer-validation/config/baseline-1024.yaml \\\n", + " --trainer.logger.init_args.name=\"{WANDB_PREFIX} (deepspeed_stage_3_offload, train-ctx=1024, data-ctx=1024)\" \\\n", + " --trainer.strategy=\"deepspeed_stage_3\" \\\n", + " --trainer.devices=\"{GPU_DEVICES}\"" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "rwkv-exp", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 9e0d7b23796f84f93d46fef44997992cc5a9bd48 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Mon, 10 Jul 2023 04:51:08 +0000 Subject: [PATCH 52/57] updating deepspeed 2 & 3 benchmark --- .../deepspeed-2-and-3.ipynb | 800 +++++++- .../torch-compile-perf-h100-ds1.ipynb | 1749 ----------------- 2 files changed, 783 insertions(+), 1766 deletions(-) delete mode 100644 notebook/trainer-validation/torch-compile-perf-h100-ds1.ipynb diff --git a/notebook/trainer-validation/deepspeed-2-and-3.ipynb b/notebook/trainer-validation/deepspeed-2-and-3.ipynb index 81640d03..22c5ee41 100644 --- a/notebook/trainer-validation/deepspeed-2-and-3.ipynb +++ b/notebook/trainer-validation/deepspeed-2-and-3.ipynb @@ -5,18 +5,35 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Deepspeed 2 & Validation\n", + "# Deepspeed 2 & 3 Validation\n", "This model being trained has the same settings as raven 1B5 model.\n", "- Layer count: 24\n", "- Embed size: 2048\n", "\n", "The goal is to validate the trainer across deepspeed 2 & 3 - with and without offload. All other training params remain constant.\n", "\n", - "Note, you will need a dual+ GPU setup, that is capable of handling deepspeed 2\n", + "Note, you will need a dual+ GPU setup, that is capable of handling deepspeed 2 (minimum 24GB * 2)\n", "\n", "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps\n", ">\n", - "> And that you have completed the `baseline-setup.ipynb`" + "> And that you have completed the `baseline-setup.ipynb`\n", + "\n", + "## 2 x A5000 (24gb, NvLink, via vast.ai)\n", + "\n", + "| Deepspeed Strat | Time | VRAM Usage | RAM Usage | Validation Loss |\n", + "| --------------------- | --------------------- | ---------------- | --------- | --------------- |\n", + "| Stage 2 | 24 mins : 55 sec | ~22.3 + 23.8 GB | ~85 GB | 6.173 |\n", + "| Stage 3 | 29 mins : 12 sec | ~23.0 + 23.2 GB^ | ~85 GB | 5.665 |\n", + "| Stage 2 + CPU offload | 43 mins : 08 sec | ~9.7 + 10.3 GB | ~128 GB | 6.124 |\n", + "| Stage 3 + CPU offload | 1hr : 42mins : 38 sec | ~7.0 + 7.3 GB | ~145 GB | 5.668 |\n", + "\n", + "---\n", + "\n", + "> ^ note in theory deepspeed 3 uses less vram then deepspeed 2, however it will also try to use up more ram then its needed for \"cache\" items if possible, maxing out to the same level as deepspeed 2 here\n", + "\n", + "> Torch.JIT was enabled for deepspeed 2, But was disabled for deepspeed 3 (not compatible). Torch.compile was disabled\n", + "\n", + "> Full report with charts and figures can be found at WANDB : https://wandb.ai/picocreator/RWKV-InfCtx-Validation/reports/-RWKV-infctx-DeepSpeed-2-3-comparisons--Vmlldzo0ODM5MjAy" ] }, { @@ -42,7 +59,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "DEEPSPEED_STRAT: deepspeed_stage_2_offload\n", "ENABLE_WANDB: True\n", "GPU_DEVICES: auto\n" ] @@ -73,9 +89,170 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting ds_accelerator to cuda (auto detect)\n", + "[RWKV.model] Running RWKV model using 'torch-jit' with torch '2.0.1+cu118'\n", + "Global seed set to 3941088705\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mpicocreator\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: wandb version 0.15.5 is available! To upgrade, please run:\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: $ pip install wandb --upgrade\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.4\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230709_163612-9qq27v2z\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-deepspeed (deepspeed_stage_2, train-ctx=1024, data-ctx=1024)\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/9qq27v2z\u001b[0m\n", + "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /root/.cache/torch_extensions/py311_cu118/wkv_1024_bf16/build.ninja...\n", + "Building extension module wkv_1024_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module wkv_1024_bf16...\n", + "/usr/local/lib/python3.11/dist-packages/lightning/fabric/connector.py:562: UserWarning: bf16 is supported for historical reasons but its usage is discouraged. Please set your precision to bf16-mixed instead!\n", + " rank_zero_warn(\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "Found cached dataset parquet (/root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 596.54it/s]\n", + "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-d9ebc51d67d5ce31_*_of_00128.arrow\n", + "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-161be9e5a7a54d76_*_of_00128.arrow\n", + "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-45459c41c653f279_*_of_00128.arrow\n", + "Setting ds_accelerator to cuda (auto detect)\n", + "[rank: 0] Global seed set to 3941088705 \n", + "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/2\n", + "[2023-07-09 16:36:32,126] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[RWKV.model] Running RWKV model using 'torch-jit' with torch '2.0.1+cu118'\n", + "[rank: 1] Global seed set to 3941088705\n", + "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /root/.cache/torch_extensions/py311_cu118/wkv_1024_bf16/build.ninja...\n", + "Building extension module wkv_1024_bf16...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module wkv_1024_bf16...\n", + "[rank: 1] Global seed set to 3941088705\n", + "initializing deepspeed distributed: GLOBAL_RANK: 1, MEMBER: 2/2\n", + "[2023-07-09 16:36:48,378] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-09 16:36:48,384] [WARNING] [deepspeed.py:637:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "Enabling DeepSpeed BF16.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "LOCAL_RANK: 1 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Detected CUDA files, patching ldflags\n", + "Emitting ninja build file /root/.cache/torch_extensions/py311_cu118/fused_adam/build.ninja...\n", + "Building extension module fused_adam...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module fused_adam...\n", + "Time to load fused_adam op: 0.0640115737915039 seconds\n", + "Loading extension module fused_adam...\n", + "Time to load fused_adam op: 0.10116028785705566 seconds\n", + "Loading `train_dataloader` to estimate number of stepping batches.\n", + "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "Emitting ninja build file /root/.cache/torch_extensions/py311_cu118/utils/build.ninja...\n", + "Building extension module utils...\n", + "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", + "ninja: no work to do.\n", + "Loading extension module utils...\n", + "Time to load utils op: 0.06395459175109863 seconds\n", + "Loading extension module utils...\n", + "Time to load utils op: 0.10399532318115234 seconds\n", + "Rank: 1 partition count [2, 2, 2] and sizes[(757504000, False), (24576, False), (24576, False)] \n", + "Rank: 0 partition count [2, 2, 2] and sizes[(757504000, False), (24576, False), (24576, False)] \n", + "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "No modifications detected for re-loaded extension module utils, skipping build step...\n", + "Loading extension module utils...\n", + "Time to load utils op: 0.0004949569702148438 seconds\n", + "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", + "No modifications detected for re-loaded extension module utils, skipping build step...\n", + "Loading extension module utils...\n", + "Time to load utils op: 0.0009634494781494141 seconds\n", + "\n", + " | Name | Type | Params\n", + "--------------------------------------\n", + "0 | emb | Embedding | 102 M \n", + "1 | blocks | ModuleList | 1.3 B \n", + "2 | ln_out | LayerNorm | 4.1 K \n", + "3 | head | Linear | 102 M \n", + "--------------------------------------\n", + "1.5 B Trainable params\n", + "0 Non-trainable params\n", + "1.5 B Total params\n", + "6,060.425 Total estimated model params size (MB)\n", + "Epoch 0: 100%|█| 2632/2632 [24:55<00:00, 1.76it/s, v_num=7v2z, train/loss=6.120\n", + "Validation: 0it [00:00, ?it/s]\u001b[A\n", + "Validation: 0%| | 0/27 [00:00) and the tensors embedded in it cannot be detected. The ZeRO-3 hooks designed to trigger before or after backward pass of the module relies on knowing the input and output tensors and therefore may not get triggered properly.\n", + "Epoch 0: 1%| | 19/2632 [00:24<56:52, 1.31s/it, v_num=t78b, train/loss=9.620][2023-07-09 13:27:34,232] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 3%| | 69/2632 [00:59<36:41, 1.16it/s, v_num=t78b, train/loss=8.620][2023-07-09 13:28:08,658] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 3%| | 79/2632 [01:06<35:40, 1.19it/s, v_num=t78b, train/loss=8.620][2023-07-09 13:28:15,525] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 4%| | 109/2632 [01:27<33:54, 1.24it/s, v_num=t78b, train/loss=9.190][2023-07-09 13:28:37,133] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 5%| | 119/2632 [01:35<33:42, 1.24it/s, v_num=t78b, train/loss=7.910][2023-07-09 13:28:45,512] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 5%| | 129/2632 [01:44<33:43, 1.24it/s, v_num=t78b, train/loss=8.440][2023-07-09 13:28:53,742] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 6%| | 159/2632 [02:07<33:01, 1.25it/s, v_num=t78b, train/loss=8.060][2023-07-09 13:29:17,175] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 9%| | 239/2632 [03:02<30:26, 1.31it/s, v_num=t78b, train/loss=7.840][2023-07-09 13:30:11,764] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 11%| | 279/2632 [03:29<29:26, 1.33it/s, v_num=t78b, train/loss=7.810][2023-07-09 13:30:38,790] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 12%| | 319/2632 [03:56<28:35, 1.35it/s, v_num=t78b, train/loss=7.690][2023-07-09 13:31:05,882] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 12%|▏| 329/2632 [04:03<28:24, 1.35it/s, v_num=t78b, train/loss=7.660][2023-07-09 13:31:12,817] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 15%|▏| 399/2632 [04:49<27:00, 1.38it/s, v_num=t78b, train/loss=7.340][2023-07-09 13:31:58,899] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 16%|▏| 419/2632 [05:03<26:42, 1.38it/s, v_num=t78b, train/loss=7.720][2023-07-09 13:32:12,770] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 16%|▏| 429/2632 [05:10<26:34, 1.38it/s, v_num=t78b, train/loss=7.590][2023-07-09 13:32:19,846] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 17%|▏| 449/2632 [05:23<26:14, 1.39it/s, v_num=t78b, train/loss=7.780][2023-07-09 13:32:33,214] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 19%|▏| 489/2632 [05:50<25:36, 1.39it/s, v_num=t78b, train/loss=7.160][2023-07-09 13:33:00,078] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 19%|▏| 509/2632 [06:04<25:19, 1.40it/s, v_num=t78b, train/loss=7.470][2023-07-09 13:33:13,465] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 20%|▏| 529/2632 [06:17<25:00, 1.40it/s, v_num=t78b, train/loss=7.530][2023-07-09 13:33:27,055] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 22%|▏| 579/2632 [06:51<24:17, 1.41it/s, v_num=t78b, train/loss=7.410][2023-07-09 13:34:00,386] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 22%|▏| 589/2632 [06:58<24:11, 1.41it/s, v_num=t78b, train/loss=7.250][2023-07-09 13:34:07,765] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 25%|▏| 649/2632 [07:38<23:20, 1.42it/s, v_num=t78b, train/loss=7.000][2023-07-09 13:34:47,598] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 25%|▎| 659/2632 [07:45<23:13, 1.42it/s, v_num=t78b, train/loss=6.750][2023-07-09 13:34:54,904] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 25%|▎| 669/2632 [07:52<23:06, 1.42it/s, v_num=t78b, train/loss=7.000][2023-07-09 13:35:01,692] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 27%|▎| 699/2632 [08:11<22:39, 1.42it/s, v_num=t78b, train/loss=7.410][2023-07-09 13:35:20,950] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 27%|▎| 709/2632 [08:18<22:31, 1.42it/s, v_num=t78b, train/loss=6.660][2023-07-09 13:35:27,584] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 28%|▎| 739/2632 [08:38<22:07, 1.43it/s, v_num=t78b, train/loss=6.970][2023-07-09 13:35:47,631] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 30%|▎| 779/2632 [09:05<21:38, 1.43it/s, v_num=t78b, train/loss=6.910][2023-07-09 13:36:15,197] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 31%|▎| 809/2632 [09:25<21:14, 1.43it/s, v_num=t78b, train/loss=6.970][2023-07-09 13:36:34,921] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 31%|▎| 819/2632 [09:32<21:07, 1.43it/s, v_num=t78b, train/loss=6.660][2023-07-09 13:36:41,969] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 31%|▎| 829/2632 [09:39<21:00, 1.43it/s, v_num=t78b, train/loss=6.720][2023-07-09 13:36:48,950] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 32%|▎| 839/2632 [09:47<20:55, 1.43it/s, v_num=t78b, train/loss=6.880][2023-07-09 13:36:56,888] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 32%|▎| 849/2632 [09:54<20:48, 1.43it/s, v_num=t78b, train/loss=6.750][2023-07-09 13:37:03,713] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 33%|▎| 869/2632 [10:08<20:33, 1.43it/s, v_num=t78b, train/loss=6.840][2023-07-09 13:37:17,424] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 34%|▎| 899/2632 [10:28<20:10, 1.43it/s, v_num=t78b, train/loss=6.690][2023-07-09 13:37:37,304] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 35%|▎| 909/2632 [10:34<20:03, 1.43it/s, v_num=t78b, train/loss=6.720][2023-07-09 13:37:44,327] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 35%|▎| 919/2632 [10:41<19:56, 1.43it/s, v_num=t78b, train/loss=6.780][2023-07-09 13:37:51,018] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 35%|▎| 929/2632 [10:48<19:49, 1.43it/s, v_num=t78b, train/loss=7.120][2023-07-09 13:37:58,071] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 36%|▎| 949/2632 [11:02<19:35, 1.43it/s, v_num=t78b, train/loss=6.500][2023-07-09 13:38:11,832] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 36%|▎| 959/2632 [11:09<19:27, 1.43it/s, v_num=t78b, train/loss=6.280][2023-07-09 13:38:18,842] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 39%|▍| 1019/2632 [11:49<18:43, 1.44it/s, v_num=t78b, train/loss=6.310[2023-07-09 13:38:59,493] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 39%|▍| 1039/2632 [12:03<18:29, 1.44it/s, v_num=t78b, train/loss=6.340[2023-07-09 13:39:13,084] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 41%|▍| 1079/2632 [12:29<17:59, 1.44it/s, v_num=t78b, train/loss=6.440[2023-07-09 13:39:39,102] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 43%|▍| 1119/2632 [12:56<17:29, 1.44it/s, v_num=t78b, train/loss=6.470[2023-07-09 13:40:05,687] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 45%|▍| 1189/2632 [13:41<16:37, 1.45it/s, v_num=t78b, train/loss=6.500[2023-07-09 13:40:51,215] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 48%|▍| 1269/2632 [14:34<15:39, 1.45it/s, v_num=t78b, train/loss=6.500[2023-07-09 13:41:43,571] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 51%|▌| 1349/2632 [15:27<14:41, 1.46it/s, v_num=t78b, train/loss=6.780[2023-07-09 13:42:36,686] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 53%|▌| 1399/2632 [15:59<14:05, 1.46it/s, v_num=t78b, train/loss=6.380[2023-07-09 13:43:09,266] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 54%|▌| 1429/2632 [16:19<13:44, 1.46it/s, v_num=t78b, train/loss=6.910[2023-07-09 13:43:28,881] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 56%|▌| 1469/2632 [16:45<13:16, 1.46it/s, v_num=t78b, train/loss=6.340[2023-07-09 13:43:55,315] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 56%|▌| 1479/2632 [16:52<13:09, 1.46it/s, v_num=t78b, train/loss=6.030[2023-07-09 13:44:02,076] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 57%|▌| 1509/2632 [17:12<12:48, 1.46it/s, v_num=t78b, train/loss=6.000[2023-07-09 13:44:22,208] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 60%|▌| 1589/2632 [18:05<11:52, 1.46it/s, v_num=t78b, train/loss=6.000[2023-07-09 13:45:14,931] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 64%|▋| 1679/2632 [19:04<10:49, 1.47it/s, v_num=t78b, train/loss=6.000[2023-07-09 13:46:13,682] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 66%|▋| 1749/2632 [19:48<10:00, 1.47it/s, v_num=t78b, train/loss=6.120[2023-07-09 13:46:58,154] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 72%|▋| 1889/2632 [21:17<08:22, 1.48it/s, v_num=t78b, train/loss=5.910[2023-07-09 13:48:26,841] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 81%|▊| 2119/2632 [23:43<05:44, 1.49it/s, v_num=t78b, train/loss=5.780[2023-07-09 13:50:53,004] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 81%|▊| 2129/2632 [23:50<05:37, 1.49it/s, v_num=t78b, train/loss=5.500[2023-07-09 13:50:59,615] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 82%|▊| 2149/2632 [24:03<05:24, 1.49it/s, v_num=t78b, train/loss=5.840[2023-07-09 13:51:12,565] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 82%|▊| 2159/2632 [24:09<05:17, 1.49it/s, v_num=t78b, train/loss=6.220[2023-07-09 13:51:19,446] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 100%|█| 2632/2632 [29:12<00:00, 1.50it/s, v_num=t78b, train/loss=5.530\n", + "Validation: 0it [00:00, ?it/s]\u001b[A\n", + "Validation: 0%| | 0/27 [00:00) and the tensors embedded in it cannot be detected. The ZeRO-3 hooks designed to trigger before or after backward pass of the module relies on knowing the input and output tensors and therefore may not get triggered properly.\n", + "Epoch 0: 100%|█| 2632/2632 [1:42:38<00:00, 2.34s/it, v_num=vv2m, train/loss=5.5\n", + "Validation: 0it [00:00, ?it/s]\u001b[A\n", + "Validation: 0%| | 0/27 [00:00=1.0.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.1.0)\n", - "Requirement already satisfied: cycler>=0.10 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (0.11.0)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (4.40.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.4.4)\n", - "Requirement already satisfied: numpy>=1.20 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (1.25.0)\n", - "Requirement already satisfied: packaging>=20.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (22.0)\n", - "Requirement already satisfied: pillow>=6.2.0 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (9.3.0)\n", - "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (3.0.9)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from matplotlib) (2.8.2)\n", - "Requirement already satisfied: six>=1.5 in /home/ubuntu/anaconda3/envs/rwkv-infctx/lib/python3.11/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n" - ] - } - ], - "source": [ - "# Install matlab plotting library\n", - "!python3 -m pip install matplotlib" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "First step figures ...\n", - "Baseline: {'it': 1, 'time': 9, 's_time': '00:09', 'loss': 10.9}\n", - "JIT: {'it': 1, 'time': 13, 's_time': '00:13', 'loss': 10.9}\n", - "Torch Compile: {'it': 1, 'time': 72, 's_time': '01:12', 'loss': 10.9}\n", - "\n", - "First 200 step figures ...\n", - "Baseline: {'it': 101, 'time': 175, 's_time': '02:55', 'loss': 8.38}\n", - "JIT: {'it': 101, 'time': 172, 's_time': '02:52', 'loss': 8.38}\n", - "Torch Compile: {'it': 101, 'time': 225, 's_time': '03:45', 'loss': 8.38}\n", - "\n", - "Last step figures ...\n", - "Baseline: {'it': 1000, 'time': 1464, 's_time': '24:24', 'loss': 6.62}\n", - "JIT: {'it': 1000, 'time': 1407, 's_time': '23:27', 'loss': 6.66}\n", - "Torch Compile: {'it': 1000, 'time': 1399, 's_time': '23:19', 'loss': 6.66}\n" - ] - } - ], - "source": [ - "# First we need to extract the numbers from the logs\n", - "import re\n", - "\n", - "def convert_time_to_seconds(time_str):\n", - " t = list(map(int, time_str.split(':')))\n", - " return sum([a*b for (a,b) in zip(t[::-1], (1, 60, 3600))])\n", - "\n", - "def extract_from_training_logs(log_file):\n", - " result = []\n", - " with open(log_file, 'r') as file:\n", - " for line in file.readlines():\n", - " # Check if the line starts with \"Epoch 0:\"\n", - " if line.startswith(\"Epoch 0:\"):\n", - " iteration = re.search(r'(?<=\\| )(\\d+)', line) # Extracts the iteration number\n", - " time_spent = re.search(r'(?<=\\[)(.*?)(?=<)', line) # Extracts the time spent so far\n", - " loss = re.search(r'(?<=train/loss=)(\\d+.\\d+)', line) # Extracts the train/loss number\n", - " \n", - " if iteration and time_spent and loss:\n", - " result.append({\n", - " \"it\": int(iteration.group(0)), \n", - " \"time\": convert_time_to_seconds(time_spent.group(0)),\n", - " \"s_time\": time_spent.group(0),\n", - " \"loss\": float(loss.group(0))\n", - " })\n", - " return result\n", - "\n", - "\n", - "# Extract the numbers\n", - "step_baseline = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/baseline.log\")\n", - "step_jit = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/jit.log\")\n", - "step_tcompile = extract_from_training_logs(\"./logs/torch-compile-perf/{DEEPSPEED_STRAT}/torch-compile.log\")\n", - "\n", - "# Print the high level numbers (quick debugging, if log has issues)\n", - "print(\"First step figures ...\")\n", - "print(\"Baseline: \", step_baseline[0])\n", - "print(\"JIT: \", step_jit[0])\n", - "print(\"Torch Compile: \", step_tcompile[0])\n", - "print(\"\")\n", - "print(\"First 200 step figures ...\")\n", - "print(\"Baseline: \", step_baseline[200])\n", - "print(\"JIT: \", step_jit[200])\n", - "print(\"Torch Compile: \", step_tcompile[200])\n", - "print(\"\")\n", - "print(\"Last step figures ...\")\n", - "print(\"Baseline: \", step_baseline[-1])\n", - "print(\"JIT: \", step_jit[-1])\n", - "print(\"Torch Compile: \", step_tcompile[-1])\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Check if the loss plot is similar\n", - "\n", - "No point having a faster JIT / torch.compile, if the loss curve does not fall at the same rate" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAHHCAYAAABKudlQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADBNUlEQVR4nOzdd3xUVdrA8d+dPmmTQiq9g1ItgIoINkQU7HVdxbara2FdXfXF3nV1dV27roi994JdsSBFepGaQCC9Z3q77x+TTMnMpBESEp7v55PdmVvmnplg7jPnPOc5iqqqKkIIIYQQ3ZSmqxsghBBCCLEnJJgRQgghRLcmwYwQQgghujUJZoQQQgjRrUkwI4QQQohuTYIZIYQQQnRrEswIIYQQoluTYEYIIYQQ3ZoEM0IIIYTo1iSYEUIIIUS3JsGMECLCSy+9hKIoLF++vKub0iqrVq3iT3/6E3379sVoNJKens6xxx7L/Pnz8fl8Xd08IUQn0HV1A4QQor1eeOEF/vrXv5Kdnc0FF1zA0KFDqa+v59tvv+WSSy6huLiY//u//+vqZgoh9jIJZoQQ3dJvv/3GX//6Vw477DA+//xzkpOTg/vmzp3L8uXLWbduXYdcy2azkZiY2CGvJYToeDLMJIRol5UrVzJjxgxSUlJISkrimGOO4bfffos4xuPxcOeddzJ06FBMJhMZGRlMnjyZr7/+OnhMSUkJc+bMoU+fPhiNRnJzc5k9ezYFBQXNXv/OO+9EURRee+21iECm0SGHHMJFF10EwA8//ICiKPzwww8RxxQUFKAoCi+99FJw20UXXURSUhLbtm3jxBNPJDk5mfPPP5+rrrqKpKQk7HZ71LXOPfdccnJyIoa1vvjiC4488kgSExNJTk5m5syZrF+/vtn3JIRoHwlmhBBttn79eo488khWr17NP//5T2699Vby8/OZOnUqS5YsCR53xx13cOeddzJt2jSeeOIJ5s2bR79+/VixYkXwmNNPP50PPviAOXPm8NRTT3HNNddQX1/Pzp07417fbrfz7bffMmXKFPr169fh78/r9TJ9+nSysrJ4+OGHOf300zn77LOx2Wx89tlnUW355JNPOOOMM9BqtQC88sorzJw5k6SkJB588EFuvfVWNmzYwOTJk1sM0oQQ7aAKIUSY+fPnq4C6bNmyuMeccsopqsFgULdt2xbcVlRUpCYnJ6tTpkwJbhs7dqw6c+bMuK9TXV2tAuq//vWvNrVx9erVKqBee+21rTr++++/VwH1+++/j9ien5+vAur8+fOD2y688EIVUG+66aaIY/1+v9q7d2/19NNPj9j+9ttvq4C6aNEiVVVVtb6+Xk1NTVUvu+yyiONKSkpUi8UStV0IseekZ0YI0SY+n4+vvvqKU045hUGDBgW35+bmct555/Hzzz9TV1cHQGpqKuvXr2fLli0xX8tsNmMwGPjhhx+orq5udRsaXz/W8FJHueKKKyKeK4rCmWeeyeeff47Vag1uf+utt+jduzeTJ08G4Ouvv6ampoZzzz2XioqK4I9Wq2XixIl8//33e63NQuyvJJgRQrRJeXk5drud4cOHR+0bOXIkfr+fwsJCAO666y5qamoYNmwYo0eP5oYbbmDNmjXB441GIw8++CBffPEF2dnZTJkyhYceeoiSkpJm25CSkgJAfX19B76zEJ1OR58+faK2n3322TgcDj7++GMArFYrn3/+OWeeeSaKogAEA7ejjz6azMzMiJ+vvvqKsrKyvdJmIfZnEswIIfaaKVOmsG3bNl588UVGjRrFCy+8wEEHHcQLL7wQPGbu3Lls3ryZ+++/H5PJxK233srIkSNZuXJl3NcdMmQIOp2OtWvXtqodjYFGU/Hq0BiNRjSa6D+PkyZNYsCAAbz99tsAfPLJJzgcDs4+++zgMX6/HwjkzXz99ddRPx999FGr2iyEaD0JZoQQbZKZmUlCQgKbNm2K2vfHH3+g0Wjo27dvcFt6ejpz5szhjTfeoLCwkDFjxnDHHXdEnDd48GD+8Y9/8NVXX7Fu3TrcbjePPPJI3DYkJCRw9NFHs2jRomAvUHPS0tIAqKmpidi+Y8eOFs9t6qyzzmLhwoXU1dXx1ltvMWDAACZNmhTxXgCysrI49thjo36mTp3a5msKIZonwYwQok20Wi3HH388H330UcTMnNLSUl5//XUmT54cHAaqrKyMODcpKYkhQ4bgcrmAwEwgp9MZcczgwYNJTk4OHhPP7bffjqqqXHDBBRE5LI1+//13FixYAED//v3RarUsWrQo4pinnnqqdW86zNlnn43L5WLBggUsXLiQs846K2L/9OnTSUlJ4b777sPj8USdX15e3uZrCiGaJ0XzhBAxvfjiiyxcuDBq+7XXXss999zD119/zeTJk7nyyivR6XQ8++yzuFwuHnrooeCxBxxwAFOnTuXggw8mPT2d5cuX8+6773LVVVcBsHnzZo455hjOOussDjjgAHQ6HR988AGlpaWcc845zbbv8MMP58knn+TKK69kxIgRERWAf/jhBz7++GPuueceACwWC2eeeSb//e9/URSFwYMH8+mnn7Yrf+Wggw5iyJAhzJs3D5fLFTHEBIF8nqeffpoLLriAgw46iHPOOYfMzEx27tzJZ599xhFHHMETTzzR5usKIZrR1dOphBD7lsap2fF+CgsLVVVV1RUrVqjTp09Xk5KS1ISEBHXatGnqr7/+GvFa99xzjzphwgQ1NTVVNZvN6ogRI9R7771XdbvdqqqqakVFhfq3v/1NHTFihJqYmKhaLBZ14sSJ6ttvv93q9v7+++/qeeedp+bl5al6vV5NS0tTjznmGHXBggWqz+cLHldeXq6efvrpakJCgpqWlqb+5S9/UdetWxdzanZiYmKz15w3b54KqEOGDIl7zPfff69Onz5dtVgsqslkUgcPHqxedNFF6vLly1v93oQQraOoqqp2WSQlhBBCCLGHJGdGCCGEEN2aBDNCCCGE6NYkmBFCCCFEtybBjBBCCCG6NQlmhBBCCNGtSTAjhBBCiG6txxfN8/v9FBUVkZycHHd9FiGEEELsW1RVpb6+nry8vJhrpYXr8cFMUVFRxDoxQgghhOg+CgsLY65iH67HBzPJyclA4MNoXC9GCCGEEPu2uro6+vbtG7yPN6fHBzONQ0spKSkSzAghhBDdTGtSRCQBWAghhBDdmgQzQgghhOjWujSYWbRoESeffDJ5eXkoisKHH34Ysf/999/n+OOPJyMjA0VRWLVqVZe0UwghhBD7ri7NmbHZbIwdO5aLL76Y0047Leb+yZMnc9ZZZ3HZZZd1QQuFEELsy3w+Hx6Pp6ubIdpBr9ej1Wo75LW6NJiZMWMGM2bMiLv/ggsuAKCgoKCTWiSEEKI7UFWVkpISampquropYg+kpqaSk5Ozx3XgetxsJpfLhcvlCj6vq6vrwtYIIYTYGxoDmaysLBISEqQoajejqip2u52ysjIAcnNz9+j1elwwc//993PnnXd2dTOEEELsJT6fLxjIZGRkdHVzRDuZzWYAysrKyMrK2qMhpx43m+nmm2+mtrY2+FNYWNjVTRJCCNGBGnNkEhISurglYk81/g73NO+px/XMGI1GjEZjVzdDCCHEXiZDS91fR/0Oe1zPjBBCCCH2L10azFitVlatWhWsH5Ofn8+qVavYuXMnAFVVVaxatYoNGzYAsGnTJlatWkVJSUlXNVkIIYTo1gYMGMBjjz0WfB6rzlt306XBzPLlyxk/fjzjx48H4LrrrmP8+PHcdtttAHz88ceMHz+emTNnAnDOOecwfvx4nnnmmS5rsxBCCNFeF110EYqiBH8yMjI44YQTWLNmTZe1qbi4uNkyKd1Bl+bMTJ06FVVV4+6/6KKLuOiiizqvQW1Q5/RQUlGI3VYUsX1g7wOwJKV3UauEEELs60444QTmz58PBKaY33LLLZx00knBUYnOlpOT0yXX7UiSM9NOr/62g7veuJ4Lfrsi4ueUt46k1lrV1c0TQgixjzIajeTk5JCTk8O4ceO46aabKCwspLy8HIAbb7yRYcOGkZCQwKBBg7j11lsjZvusXr2aadOmkZycTEpKCgcffDDLly8P7v/555858sgjMZvN9O3bl2uuuQabzRa3PeHDTAUFBSiKwvvvv8+0adNISEhg7NixLF68OOKctl5jb5Ngpp10GgUNGox+NfgDUKHTsG3n2i5unRBC7F9UVcXu9nbJT3MjDC2xWq28+uqrDBkyJFgzJzk5mZdeeokNGzbwn//8h+eff55HH300eM75559Pnz59WLZsGb///js33XQTer0egG3btnHCCSdw+umns2bNGt566y1+/vlnrrrqqja1a968eVx//fWsWrWKYcOGce655+L1ejv0Gh2px03N7iyXTxnM5VPejdg2Yf6BODQSHwohRGdzeHwccNuXXXLtDXdNJ8HQ+tvpp59+SlJSEhBYgzA3N5dPP/0UTcP945ZbbgkeO2DAAK6//nrefPNN/vnPfwKwc+dObrjhBkaMGAHA0KFDg8fff//9nH/++cydOze47/HHH+eoo47i6aefxmQytaqN119/fTBf9c477+TAAw9k69atjBgxosOu0ZHkziuEEEJ0omnTpgVn8i5dupTp06czY8YMduzYAcBbb73FEUccQU5ODklJSdxyyy0R+TTXXXcdl156KcceeywPPPAA27ZtC+5bvXo1L730EklJScGf6dOn4/f7yc/Pb3Ubx4wZE3zcuNRA49IDHXWNjiQ9Mx3IgRHw4EvK7uqmCCHEfsWs17Lhrulddu22SExMZMiQIcHnL7zwAhaLheeff56ZM2dy/vnnc+eddzJ9+nQsFgtvvvkmjzzySPD4O+64g/POO4/PPvuML774gttvv50333yTU089FavVyl/+8heuueaaqOv269ev1W1sHLaCUGE7v98P0GHX6EgSzHQgFQUFQCMfqxBCdCZFUdo01LMvURQFjUaDw+Hg119/pX///sybNy+4v7HHJtywYcMYNmwYf//73zn33HOZP38+p556KgcddBAbNmyICJY6Wmdco61kmEkIIYToRC6Xi5KSEkpKSti4cSNXX301VquVk08+maFDh7Jz507efPNNtm3bxuOPP84HH3wQPNfhcHDVVVfxww8/sGPHDn755ReWLVvGyJEjgcBMqF9//ZWrrrqKVatWsWXLFj766KMOTc7tjGu0VfcMY/dRBrx4AI2zpqubIoQQYh+1cOHCYB5KcnIyI0aM4J133mHq1KkA/P3vf+eqq67C5XIxc+ZMbr31Vu644w4AtFotlZWV/PnPf6a0tJRevXpx2mmnceeddwKBXJcff/yRefPmceSRR6KqKoMHD+bss8/usPZ3xjXaSlH3ZE5ZN1BXV4fFYqG2tpaUlJS9eq3G2UwLDn2Cgw44aq9eSwgh9ldOp5P8/HwGDhzYJTNnRMdp7nfZlvu39Mx0oHFODz5FRa8xdHVThBBCiP2GBDMd6LGSGhIUF0XGtK5uihBCCLHfkARgIYQQQnRrEswIIYQQoluTYKYDzerXi8n9elPqLO/qpgghhBD7DcmZ6UB1GgWHRoOq+ru6KUIIIcR+Q4KZDpS66yLMXh+pJxzQ1U0RQggh9hsSzHSgXZ7R2N0+9PrErm6KEEIIsd+QnBkhhBBCdGvSM9OBJqT+Bz8+rPVDIH14VzdHCCGE2C9Iz0wH2pC2k5UZxThsJV3dFCGEEPugiy66iFNOOSXqsaIozf40rs0kYpOeGSGEEKKLFRcXBx+/9dZb3HbbbWzatCm4LSkpqSua1W1IMCOEEEJ0sZycnOBji8WCoigR20TzJJgRQgjRc7ht8fcpWtCbWnmsBvTmlo81yOzVfYEEM0IIIXqO+/Li7xt6PJz/Tuj5v4aAxx772P6TYc5noeePjQZ7ZfRxd9S2r52iQ0kCsBBCCCG6NemZEUII0XP8X1H8fYo28vkNW5s5tsl3/blr298msddJMNOBnBgAL76EXl3dFCGE2D+1JYdlbx0rOp0MM3Ugf+PHqTN2bUOEEEKI/YgEM0IIIUQn8fv96HQyKNLRJJjpQHq8ACiuui5uiRBCiH1RWVlZsH7MSy+9xIcffhh1zEUXXURNTU3nNqybk2CmAzUGMxpXfRe3RAghxL6kurqaTz/9lB9++IFjjz22q5vT40hfVwca6Pbh1njRauRjFUIIEXLxxRezbNky/vGPfzB79uyubk6PI3fdDjS/qIoExUWRMaOrmyKEEGIf8sEHH3R1E3o0GWYSQgghRLcmwYwQQgghujUJZjrQn3unM6t3LuWuGOt3CCGEEGKvkJyZDrRTr8Wh0eDze7u6KUIIIcR+Q4KZDpRXfDJerxfL8cO6uilCCCHEfkOCmQ602TkVu9uHwWjp6qYIIYQQ+w3JmRFCCCFEq7z00kukpqYGn99xxx2MGzeuy9rTSIKZDnRIyotMzvgfdmtxVzdFCCHEPkZRlGZ/7rjjDgBWrlzJmWeeSXZ2NiaTiaFDh3LZZZexefPmrn0DwNlnn71PtKMpCWY60B8Z61mdtQWbdVdXN0UIIcQ+pri4OPjz2GOPkZKSErHt+uuv59NPP2XSpEm4XC5ee+01Nm7cyKuvvorFYuHWW2/t6reA2WwmKyurq5sRRYIZIYQQohPk5OQEfywWC4qiRGzTaDTMmTOHE088kY8//phjjz2WgQMHMnHiRB5++GGeffbZ4Gv9+OOPTJgwAaPRSG5uLjfddBNeb2gm7dSpU7n66quZO3cuaWlpZGdn8/zzz2Oz2ZgzZw7JyckMGTKEL774InjODz/8gKIofPbZZ4wZMwaTycSkSZNYt25d8Jimw0yxvPDCC4wcORKTycSIESN46qmnOu5DjEOCGSGEED2G3WNv8483rJyG1+/F7rHj9Dpb9bod6csvv6SiooJ//vOfMfc3BhG7d+/mxBNP5NBDD2X16tU8/fTT/O9//+Oee+6JOH7BggX06tWLpUuXcvXVV3PFFVdw5plncvjhh7NixQqOP/54LrjgAuz2yPdxww038Mgjj7Bs2TIyMzM5+eST8Xg8rXoPr732Grfddhv33nsvGzdu5L777uPWW29lwYIFbf9A2kBmMwkhhOgxJr4+sc3nPHzUw0wfMB2Ab3d+y/U/Xs8h2Ycw/4T5wWNOeO8Eql3VUeeuvXBt+xvbxJYtWwAYMWJEs8c99dRT9O3blyeeeAJFURgxYgRFRUXceOON3HbbbWg0gX6KsWPHcssttwBw880388ADD9CrVy8uu+wyAG677Taefvpp1qxZw6RJk4Kvf/vtt3PccccBgYCoT58+fPDBB5x11lktvofbb7+dRx55hNNOOw2AgQMHsmHDBp599lkuvPDCNn4irSfBjBBCCLEPUFW1Vcdt3LiRww47DEVRgtuOOOIIrFYru3btol+/fgCMGTMmuF+r1ZKRkcHo0aOD27KzswEoKyuLeP3DDjss+Dg9PZ3hw4ezcePGFttls9nYtm0bl1xySTBgAgL11yx7t2SJBDNCCCF6jCXnLWnzOQatIfj4mH7HsOS8JWiUyCyMhacv3OO2tWTYsEDB1T/++CMioGgvvV4f8VxRlIhtjcGQ3+/f42sBWK1WAJ5//nkmTozsIdNqtR1yjXgkmBFCCNFjJOgT9uh8nUaHThN9a9zT122N448/nl69evHQQw/xwQcfRO2vqakhNTWVkSNH8t5776GqajAg+eWXX0hOTqZPnz573I7ffvst2LtTXV3N5s2bGTlyZIvnZWdnk5eXx/bt2zn//PP3uB1tIcFMB3JhALz4zeld3RQhhBDdTGJiIi+88AJnnnkms2bN4pprrmHIkCFUVFTw9ttvs3PnTt58802uvPJKHnvsMa6++mquuuoqNm3axO233851110XzJfZE3fddRcZGRlkZ2czb948evXqxSmnnNKqc++8806uueYaLBYLJ5xwAi6Xi+XLl1NdXc111123x22LR2YzdSBfw8ep6s1d3BIhhBDd0ezZs/n111/R6/Wcd955jBgxgnPPPZfa2trgbKXevXvz+eefs3TpUsaOHctf//pXLrnkkmCy75564IEHuPbaazn44IMpKSnhk08+wWAwtHwicOmll/LCCy8wf/58Ro8ezVFHHcVLL73EwIEDO6Rt8ShqazOOuqm6ujosFgu1tbWkpKTs1WuNmn8wisbNi8d8wKF9huzVawkhxP7K6XSSn5/PwIEDMZlMXd2cHuOHH35g2rRpVFdXt1hLpqM097tsy/1bemY6kA4fAIrb1sUtEUIIIfYfEsx0IAOBokIaZ03XNkQIIYTYj0gCcAdK9amYVR+KIjGiEEKI7mXq1KmtrnWzr5FgpgN9WFhBguKiaFpmVzdFCCGE2G9IF4IQQohuqbv2IoiQjvodSjAjhBCiW2msYtt0gUTR/TT+DptWK24rGWbqQNfkpOLRqFzvqiKvqxsjhBA9lFarJTU1NbimUEJCQsQ6RWLfp6oqdrudsrIyUlNT93i5AwlmOtAakx6HRoPH37ql0oUQQrRPTk4OEL1IouheUlNTg7/LPSHBTAcaVHokXr+XlGMHdXVThBCiR1MUhdzcXLKysvB45Atkd6TX6ztsAUoJZjrQGvsp2N0+jOaMrm6KEELsF7Ra7V5fkVns+yQBWAghhBDdmvTMdKCxie/hM3tx2kdDer+ubo4QQgixX5BgpgNty/oVh0ZDfV0+IMGMEEII0Rm6dJhp0aJFnHzyyeTl5aEoCh9++GHEflVVue2228jNzcVsNnPssceyZcuWrmmsEEIIIfZJXRrM2Gw2xo4dy5NPPhlz/0MPPcTjjz/OM888w5IlS0hMTGT69Ok4nc5ObqkQQggh9lVdOsw0Y8YMZsyYEXOfqqo89thj3HLLLcyePRuAl19+mezsbD788EPOOeeczmyqEEIIIfZR++xspvz8fEpKSjj22GOD2ywWCxMnTmTx4sVd2DIhhBBC7Ev22QTgkpISALKzsyO2Z2dnB/fF4nK5cLlcwed1dXV7p4FCCCGE2Cfssz0z7XX//fdjsViCP3379u3qJgkhhBBiL9png5nGtRpKS0sjtpeWlja7jsPNN99MbW1t8KewsHCvtjOcm8Cqn35TaqddUwghhNjf7bPBzMCBA8nJyeHbb78Nbqurq2PJkiUcdthhcc8zGo2kpKRE/HQWL4GS2qohsdOuKYQQQuzvujRnxmq1snXr1uDz/Px8Vq1aRXp6Ov369WPu3Lncc889DB06lIEDB3LrrbeSl5fHKaec0nWNbgef18uK/56L3l3HgEsWkNprz1cIFUIIIURAlwYzy5cvZ9q0acHn1113HQAXXnghL730Ev/85z+x2Wxcfvnl1NTUMHnyZBYuXIjJZOqqJjdLix8/oHgcEdtXrvuOH7RLSTL68S35lINnXto1DRRCCCF6oC4NZqZOnYqqqnH3K4rCXXfdxV133dWJrWo/I24caNA4qiK217hqedmSQqbXy6F+Xxe1TgghhOiZ9tmcme5IAZQYwZlfF+hJqtZq8ajeTm6VEEII0bNJMNOBvi8oZ01BITnmyNo43qS8wP8rCq+WvIPNXt8VzRNCCCF6JAlmOtkiYyU3vDqzq5shhBBC9BgSzHSBZfqqlg8SQgghRKvss8sZdEe3Zabg06hc6q4hL2y7obYg4rj+LvnYhRBCiI4iPTMdaFGikW8SE3D5XJE7VH/EU51fPnYhhBCio0gXQQcaXjEav+olMVnWgxJCCCE6iwQzHej3+ouwu30kJDZf4bdW7+6kFgkhhBA9n4x3dIEyndLVTRBCCCF6DOmZ6UDDTd/hNXhwu8YDCXGPU7ydt/ilEEII0dNJMNOBdud+hkOjobb6FMjNi3uc0SPBjBBCCNFRJJjZCxb8chel1RfRf+BsftlaQY7WHLFfIf56VEIIIYRoGwlm9oLd3kreXP4Cq77JptbhYVh2MuZUPw5NIEXpAKWgaxsohBBC9CASzOwFmxJ8jLMncIBpPpW915Jj7UWxJpRr7dAkdmHrhBBCiJ5FZjPtBY+VljOsNhOdaTfFegWv3hqx/wyr5MwIIYQQHUWCmb0gzecnQ6llVWo1AGuTIisCD/Dqu6JZQgghRI8kw0x7wYV52cD2rm6GEEIIsV+QnpkO5CGyx2WIO3al39UGZ2c0RwghhNgvSDDTgTxoW3Xc1wn2vdwSIYQQYv8hwUwXSFfjF9QTQgghRNtIMNOBNPgjnm81GKKOGelyU2+6tbOaJIQQQvR4Esx0IFXj7eomCCGEEPsdCWaEEEII0a1JMNOBZtVbWzxmo9GA13VlJ7RGCCGE2D9IMNOBLH5/ywcBqiw0KYQQQnQYCWaEEEII0a1JMNOBXrHImktCCCFEZ5NgphPEqwQshBBCiD0nwUwHGl+VFbVtjAMeKK/sgtYIIYQQ+wcJZjrQ7+UXBx/39Xi6sCVCCCHE/kOCmQ6Up9uJuWFGU6E+sOikqsAaY2Ql4FUmV6e3TQghhOipJJjpQDnZb+PQaDi9zsoAd6BnpkTn565eGVHHLt+1tbObJ4QQQvRIEsx0oFVJgeUM3ktJosAQ6Jk5xnhEcP8RrrTgY6vb2bmNE0IIIXooCWY6kE6NLIY3quRAhg6bx9BdRzC2fCCjsi9E7wsEORp3y9WChRBCCNEyCWY6kFdRgo/H1iWxse44FI2GFfUn83PFXzCmTcNMIF9G46yivLqIovIdXdVcIYQQokeQYKYDacN6ZjSeZGp8OVHHpPlUenl9VNbs4qQPj+Okz2ayeM3CzmymEEII0aPouroBPYmvoWcm2+tll6WQXmk3UlIwgzEDF2LV+fHZHuTV3bWkYuWNlJ3YNYFYcm3+Lxw25oSubLoQQgjRbUkwsxfYFQ312kCg4vE5yDcBaCgrfz14jNncD+xd0z4hhBCiJ5Fhpr2gMZAx+/2M0OUFtycSqjdjShrOEIcSda4QQggh2kZ6ZvaiXK8PQ9hHfIRmADdkJ+HSJDDDW9WFLRNCCCF6DumZ6WQbjDpWmkw4PdWUGXxd3RwhhBCi25NgpgPNG3V/xPPtBj3F/uqIbf0rpjF89yRc7lLqGoaj3MZendZGIYQQoqeRYKYDnTz8kKht5f764ONf/AVscM5ied0pGHWhasCOxN6d0j4hhBCiJ5JgZi/zaROCj224g4/7GfowzikLTgohhBB7ShKA97Iay3CwfQFAnbkPo8zv4tG78LqPDh6j8Xu6qnlCCCFEtyfBTAdSNNEfp1lvDj52mnuTn/EZdVoNTseQ4Pbkmg2d0j4hhBCiJ5Jhpg6UkNCLKy1jOFJJIksZTK7mCK6aOJvRiaeSwcFcfsjs4LFF/mpWmYxd2FohhBCiZ5CemQ52xSmvRW17/Yy7orY51FD+zEhDv73aJiGEEKInk56ZLuLRJwPQx+MhUWPq4tYIIYQQ3ZcEM13k1fpPu7oJQgghRI8gwUwn8yqR6zHt0uspkaUNhBBCiHaTYKaTqahR23Z5K7qgJUIIIUTPIMFMJ3Ojj9qWkji4C1oihBBC9AwSzHQyH9qI5zkeP5XayV3UGiGEEKL7k2Cmi5XoNbz2/acU1Ti6uilCCCFEtyTBTCfT4o/altn7RUrqnF3QGiGEEKL7k2CmkxnDFptstN0UnRQshBBCiNaRYKaTaWLELWOdLqw1Gzu/MUIIIUQPIMFMJ/tiR/Q07NUmIzUSzAghhBDtIsFMJ1PRMqemjhyvt6ubIoQQQvQIEsx0MgWF66pr8G/9e1c3RQghhOgRZNXsTnZ3ZiJejQlfsbWrmyKEEEL0CBLMdLJfE/RYtUaG9V5AZVc3RgghhOgBZJipkw2tHAXAZnN0vZnO9Ef5Li7/+F98uOG3Lm2HEEIIsackmOlkq+vP6+omAHDNl/eyuPplbllyZVc3RQghhNgj+3wwU19fz9y5c+nfvz9ms5nDDz+cZcuWdXWz2k1By7m19UCgvkwjd3LfTm1HjWt7oD0aT6deVwghhOho+3wwc+mll/L111/zyiuvsHbtWo4//niOPfZYdu/e3dVNa5dhpu/5IDkRCNSXaeTXJXRqO1LUuk69nhBCCLG37NPBjMPh4L333uOhhx5iypQpDBkyhDvuuIMhQ4bw9NNPd3Xz2mV3zkKcmq7/2DN8tq5ughBCCNEh9unZTF6vF5/Ph8lkithuNpv5+eefY57jcrlwuULDN3V1+1YPRJ02diCjdVZ3ajuyvQobUPl7VedeVwghhOhoXd9F0Izk5GQOO+ww7r77boqKivD5fLz66qssXryY4uLimOfcf//9WCyW4E/fvp2bi9JeekdZVzdBCCGE6Jb26WAG4JVXXkFVVXr37o3RaOTxxx/n3HPPRRNnqObmm2+mtrY2+FNYWNjJLW67PI8XvbJPd5IJIYQQ+6x9PpgZPHgwP/74I1arlcLCQpYuXYrH42HQoEExjzcajaSkpET87Ou+3FXEQHOfTr3mLn1g+e5H09M69bpCCCFER9vng5lGiYmJ5ObmUl1dzZdffsns2bO7ukkdylEVe9hsb+nakn1CCCFEx9nng5kvv/yShQsXkp+fz9dff820adMYMWIEc+bM6eqmdZjlJiPFa/7XqddM9ZkBGFub3KnXFUIIITraPh/M1NbW8re//Y0RI0bw5z//mcmTJ/Pll1+i1+u7umnt8vf0MznAlUyS10iCT8cYm5E5udm8m2Lv1Hb4PHPoU3ASm8r+1KnXFUIIITraPp91etZZZ3HWWWd1dTM6zMUn38bF3BZ8/u8351JZ/w0JalKntqNGGcVGR/eY6SWEEEI0Z58PZnq6zP5z+eOj4xg0OqdTr5uo7mRK1kuofj0ws1OvLYQQQnQkCWb2EZ+vLeGnLeUcOTRzr1/L7/Ox3nL/Xr+OEEII0RkkmNkHHJ6+AIflDz78bgRHDn17r1+vsHTbXr+GEEII0Vn2+QTgnq5i5+Oszd7IVpOKQ63olGsm6hK5rzxwrVSfTNIWQgjRvUkw08Vc3prgY7WTqr/oNFpGuDwAKJ1yRSGEEGLvkWBmH2JTZCVrIYQQoq3aFcwUFhaya9eu4POlS5cyd+5cnnvuuQ5r2P6os3pJ3l+Vz2l9cgFQO+maQgghxN7SrmDmvPPO4/vvvwegpKSE4447jqVLlzJv3jzuuuuuDm3g/iTD3zn52B/+9mbwsQQzQgghurt2BTPr1q1jwoQJALz99tuMGjWKX3/9lddee42XXnqpI9sn9oKUlOXBx1YSurAlQgghxJ5rVzDj8XgwGo0AfPPNN8yaNQuAESNGUFzcuQsm9iT+TkphchNaCsKHtlOuKYQQQuwt7bp7HnjggTzzzDP89NNPfP3115xwwgkAFBUVkZGR0aEN7Ol8GkPw8XrTAIrKd7CrrCDqOKfHzbqSnR1yzZLEzpkCHsuusgKKynd02fWFEEL0PO0KZh588EGeffZZpk6dyrnnnsvYsWMB+Pjjj4PDT6J1KlNHBx/b/SXM+nQmsz4/iRUbfow47qhXz+XcL2dy3RdP7vE1q3WhVGMj7j1+vdZaseFHZn1+ErM+ncn6bctbPkEIIYRohXZlnE6dOpWKigrq6upIS0sLbr/88stJSJAcjPayaarwaQKBxrKqUg4K22fXbAZgy643gL912DVNuDrstVqyruAXPIoCCqzf/isHDj6k064thBCi52pXz4zD4cDlcgUDmR07dvDYY4+xadMmsrKyOrSB+xMdvuBjnz52UKjDs8fXOb3OGnzc3yMVgIUQQnRv7QpmZs+ezcsvvwxATU0NEydO5JFHHuGUU07h6aef7tAG9nRpdX8EH2taUQF4gsPYodd/vNja8kEdJEWbGHzsTurdadcVQgjRs7UrmFmxYgVHHnkkAO+++y7Z2dns2LGDl19+mccff7xDG9jT6b2hqr8OTSiXxeAojzguuWENpUOcXmqtVVz9/DRGLxjN/a/Nwe128ff/ncToBaOZ+dpVXDH/dK57YTqFJdsBePf3XVzz3HHMfP4wjn95DuuNoaRjv6oy4KbPuPn9NeRXxK5A/MbqH7n4xVl88csrwW3l1jrOemceV37yaMxzrvzkUc56Zx7l1rrgtoGGPAa5Az1LXoOlVZ+PEEII0ZJ2BTN2u53k5GQAvvrqK0477TQ0Gg2TJk1ixw6ZqdIW/TWxZ38Z7aVxz/ngxyf5wRCYkfS6dzkvL7yXb3SBz32n90d+1mym0redN75/AJfXx03vreF7Ywk7DVaK1eX8ERbMNHpjaSEv/pwf83oP/n4jy7T5PLrxkeC2Z5d/ykb7x/xU9SLLd22NOP733dv4qepFNto/5ullHwe3u00Z2DDFfV9CCCFEe7QrmBkyZAgffvghhYWFfPnllxx//PEAlJWVkZKS0qEN7OkGaXrF3G5U9BHP67WBX1Wp1k+NIfKcOkdV1Pm7dTr8fg1+P3j98ev8Hj0ojeSRN3FI/3m4y++OeYxPG+ixKdaH5fTYQvWE6t2OiONtbmfwsalyZfCxNX0UNWoSAFp3fdw2CSGEEG3RrmDmtttu4/rrr2fAgAFMmDCBww47DAj00owfP75DG7g/mmazM8LUP+a+T5JduI3N1/KZVW/li52lZPW/MbjtQGt0b0y4TQk+atWimPsM3kCezoyqUICVbA314ujrInvjFFdoaEnnCwU6G2qW4jLWAmC0FjbbHiGEEKK12jU1+4wzzmDy5MkUFxcHa8wAHHPMMZx66qkd1rj9gU2NnBqd5PfzeFkFa0bGPt7s18feEaZSq6WyoSfH63UyKfUN1ie1v55MmlehVAfjXc7YBzTp+NG6aoKPB4T3PKmyEpQQQoiO1+76+Tk5OYwfP56ioqLgCtoTJkxgxIgRHda4/cFSX0HEc6smNKfJ7vaycF0JpXVOkhoSgA3qxeg8dTTnlwQzx/XPZdu2z3jig5tYn7s65nG371YZ4A5N9V6pq4vKfwHopQR6U3orlTFfJ0MfqjW0atPP7Fj1GQApPh99taFepAl2G0l+mQouhBCiY7UrmPH7/dx1111YLBb69+9P//79SU1N5e6778YvN6s20Wqih3/GDuzHJudOHnz/Pf717nNc9tz7EfsT67dHPM/KOinma3/Ms7zu/SHutft7POjDulXsWj8Xf3Ve1HFFukAH3q9mc9S+I+0OEnSh7Tf+dDlpZe/FvJ5B0ZLj9aJVVRRFiXmMEEII0VbtGmaaN28e//vf/3jggQc44ogjAPj555+54447cDqd3HvvvR3ayJ4sZ8BNGP84CZcm8ubuVN3sqHqUsoE2xpYNwl14CqmKD1v2ICByjSa3vuVpzoc5HCxuEoy8mulliyGyOJ+qjUzmBajWBhajfM2SzE0tXKdaq3B7r3QA6rRa6v2RQ1Mf7C4BYP3QQS22WQghhGiNdgUzCxYs4IUXXgiulg0wZswYevfuzZVXXinBTBuNrEtFVfystoRm+GTmHIt5+8dker3oVC3ppm3Up60nzbseGB1xvl/bciG9poEMwHeJbVt6oq87OuflpwQzV3sjAyC7JtTht8q3g6MbHu/2lLMwPZUcrw9ZyEAIIURHadcwU1VVVczcmBEjRlBVFT1NWDTvp+Kb+bloHmOcgSTds+vqMSX248w6P9NtdsYaVqHV1VJgBHdD/ko4a9Uve7V9Axs6V4xlU2Lur/RUBx87NJH/pHSaUMBU4a3hVUsKnyfJ+l1CCCE6TruCmbFjx/LEE09EbX/iiScYM2bMHjdqf1K1+3kO6T+PKZmPc11lHXeXV7LEZOLhtx7C46/jVUsKnyYbKUwNDC0l+3exqeitiNfYXPxZp7e7V/rU4GODIXZtoWSfn5wB10Zt32A0skWvZfX377D17oNY8taDwX0OWz2rHzyO1Q8ci62+pqObLYQQogdq1zDTQw89xMyZM/nmm2+CNWYWL15MYWEhn3/+eYc2sKdzuIrZlOBjBGXU+qewKGE5BQY9I3t9C2GdXJW6QNz5VVJi1Gt4PbuYV1uNU1F4JCMtan+4HLdCiWHPp0ib0yZS/+0DAKTPiK4t1MepQyk9vumIWFCNVge//Ichvm0M2XgfEKiJs23NL4x1LAVg7crvGT1FpvoLIYRoXrt6Zo466ig2b97MqaeeSk1NDTU1NZx22mmsX7+eV155peUXEFH+SPCSOvMKvm7IY6k3OHg7PfDrKdPFjjmn17s5r7aeGfUKx9vsjHO5Yh4XTt8w8TvN54u5/7Ka6GGsZE8g38aVtajF1zc0TGYr23UpG+yRw1JefVLwcba5L/fpj+HIfr05NbdPcHtd5iGcltuXg/v3ZY1tS4vXE0IIIdrVMwOQl5cXlei7evVq/ve///Hcc8/tccP2RxqtjpEuNxuNBsa43HyeFLtAnlZVmbHlGEYn2TjP9Q75mhSO6t8n5rFNFRoCs6YaZyi1hqf+QEheToI39M/FVf8H45K+wOZNB0JBiwYVUBiWMx+7zk154alw6J0AOJIHAmB2ptMLHYWpi6nXaqkJa8pO6xa2mAJtVJtW4xNCCCFiaHfRPNGxptrsZBlD1XI3G+JX+vUpCjstgaUH8vU6fkjuuKTr8U4Xfr+fN1b/yE/5G+IeV1b2Edv6/kjJwA8oK/6FUmstT/72Cc6GKebrklxsN6m4POVR5w5Uikmo/gOnLtQLVGoNPC7atSbuNStKCln74/u4XU78Ph+f/fwSPyz/oL1vVQghRA/R7p4Z0bH0EFFIzqE0H2dWOoahGoo5PzcnuAhlS8Y4XawxNT+N++bMDM5e8gnPbb4FgC8zfsRkLgi0SesNHpekhFa/9vu9nPHeVdSwqlXt2GA0YvXZOaPWxxsNBYLPfO9qPjrxQf688ibm94vdy+R+9hhGq6Us3nIx5cNGMS//MQDeSM1j1JCJrbq2EEKInkd6ZvYxG42BisC79c3HmYOHns6AySdHBTJH2R0c7+0bdfxhVh1/rm1+GQQI1IgpKwstf1BYU8nKtAoAdhpDwdY4fX8sYXk3rQlkkqpDPT07XMUc7gr1KFWzkrrKYv4wxF8Q8/tkG8f3zeNT5y8UV4aWXdhZsqnFawshhOi52tQzc9pppzW7v6amZk/asl9SG3pjvk5M4HJ3y8EGwEn+Qdx/3kGUVfeDyJUNOKsohyl3f86cZ4ay3BzqPbnopDdYvWIB1H0a8zVHutz8o6qaB1wXkWwIrWit+EIVfDV7uFCkokYmHbuI7CVy+lxck50ZfO7TR87c+lIdTbFuN+VaE/3CtvsMSQghhNh/talnxmKxNPvTv39//vznP++ttvZI5WkHBR87/S3PRgpnNFoYWxt5I38+L9DbMdEZuYyA4m3+tTcaDVyam02qZXHEdo29kn+VBXpmDnG2rX0t+cEcOY283F2JJ2yozZ4SueTByl67AajReiK2exJzO7RdQgghupc29czMnz9/b7VDAKrW1PJBLViVEJgadH5tPeVaLW+nJAOgtUcn4sayPK2G5Z7fgs9vXfxXTmkY8lpqNnH2c+P5y7h5vFr6ErXm0DQkjarib+PikYuSbc3uf2rjjWxa8yhmsxdrRiiw8aIy3jiYZJ+/1flCQgghei65E3SxfpbeAKiqQl7OUJLVUa0+12zQsrP6TzH3rTAZg4FMq9vi8URt26XX81liaLhng9HLa1u+pEjnjjhubEONm4MdkT1CfmXPcsy/1ZfwqbeCH0qXBrdl+nzoFC1JakNRmz0c/hJCCNG9STDTxa6ZNIs7DnmW+ce+T3aShY/OeJa5Bz5MblhQ8/CI2zjOPiTqXINOw5vXXow2xr3c10wvyUFOJzcwmecKQttGuVyMdLljHp/fZJp4rb4XpUpoaEfVhpJ2Z1sje1uqUscGHydoQj1P7oRsdMQu3BfPEHegfRoMlOYdjV8NvEdTzdbmThNCCNHDSTDTxTQaDacfeDiH9gkEK5lJKVxyyHS0mlBy7PSJZ3KmaRhn19VHnZ+XakaJUVzu2rBE2ka1aYEAaYXJRP/hx+DxWbi/rIILKjTMKu7d7vfgTQoFNs0NNA019mWQO9D74zVlROz7auduPCnRs7DC+Rr+uebrh1LoLKBU3/rCf0IIIXouCWa6kYo4VXsPjNOj0pQaNuRj9zko1fvI9PnYWXM0S5JdfBlj3adYjN7I3pdfVr3NSlOg1+XWzIxYpwDgNaTgJNSLU0/oerk+H7RQWyffEGi/3V9ClaukVW0VkWwuF6+s/I5ya+tmzgkhRHcgwcw+Kt0TebP2KzC8YZgl3RKZJ/PXqlCPTaY3kEfi3x05jV6j0aENH3oypfFCbj2X5mbz+8Cv+DYjutcnnhz7JtLVUI2Yt+o/jHtsSv3m4OO6XuMpU1MD7fHaI47bpfaitaqNuxngsLd8oIhy1ns38NCaaznpnTld3RQhhOgwEszso9K9gWq7Y+oDizymjz+J/1lSAHBpsuOe96esswHICJvmfYQrlYNGHMk5Y6ZhUUeTqUxg2pjjOTv7TACs7ZgRZFKjp2kfYNNzbVVNxDaDNxQkba5diddYHTi/rgCjL5Sg/KeMA1o94wogz1bNi8WlPF1SRq4xq42t33/tdAam3ts1m1s4Ugghug8JZvZRvf1JHGezk2UL9Fj0HXYQB1T1YXxFHqpijnnOULebi0++DYBeSmCto0FOhWcu/wmNVku/1Ex+vuh1vvvz/zDpDVx88u3NtkHxR//zmFVvZZanX4yjYcnOuzmnSV5Pb02olozXHzkcNswb6t2ptBSg8cTubWlM/G3qUKeLyQ4nidrYn4eIwWcBwO+OPxwohBDdjQQz+6gJnkz+XVbB8Pp0AHQ6EzWOEaiqAcX6fcSx/8gJHLMlbCkAJeNXAAqM/mavk+fxxtyuU1VUTeS5T5aUcW9FFUZi5+4YFRv+sJEss9/PIG2o12R8k6GhRELPtZUT4rZxmNsTNeXbrrrYaNCzQyfLi7WJJxDEuCuP6uKGCCFEx5FgZh+l+ur5V3oq1qyfgtssyStYlVlAnfPniGP7OgNTp8eWhQrLbTY35M60UMguUY0d7HhjnLfWGL1IZaI/dL5hxN0c0b8vR9sCQYq+Sf2XRDTB2UwA9ZpAUHRyvY2/VMWvLnxSpZmnS8tR1FCbNnh3c1bvXE7qm0d122r1CSGE6GEkmNlnOfCg8E1CAhBYmTpbtTLS5aa3P3LWUXHZVSRvu5QVVWfv1RY9k2bhiuxMbjP82Oxx3yUG2lyn1fL3mmfZunMd1bXl3Lb1Vq6oqeXnHYX0W/sj2xsqC3+SnMjrg1bwxA//ifl6V/bXcHKfXDQNw16fFBZhVEK1b3Y3szjl5tJ6Drr7a0767094fM33Uu2J0srdTH9hFFP/dyDrti6J2n/tK0cwcf4ofl3+1F5rQ2tka0oBMOW+zyHzR/H4O3O7tD1CCNERJJjZR20dcADvpCRh8Qd6QzweG1+medloNDDWGxnMnDP5KIrcQzht4ujgthN9AwA4zpPX7HW2xAkEsrxeJjQZ2tGrKj8nmCkOG9qxaQL/hKbYHTFfp1ar5dd1H7N843dsN+h5NzkJi1/F7KlHH9bTUqPVUpRUEXHuMyVlPFYaSAp2KApKQxUbhch6Ngm6+FPKlxdUc5HrVU4qfYaS4t1xj9tTS9YvpEivUKnT8Ov66MU8v/PXYdcoLNz8/l5rQ2vUGyqDj10ahTfrVjdztBBCdA+ScLCP+sup9zO74kp6pea0eOzVxwzlwiMGkGIK9VY8ePEnXFu+g7zM/q26nkZV+erkLzn7w+Oo1Gk53manVJsJBIZ/Pp/+EVa3lj89+xV2fxIMui/i/EMdThYltJyIu95owKYoOFHp59ZTqQ9VAb7QWs5j6aGE4TKtli+SQr08EJ3fM8yhITchdkIywMqaL1g4dAVH2B3MdNUAzRfma68UXfMrd19YW8cCSwqpir7Z4/Y2FwYglFCdZ53YdY0RQogOIj0z+7CcXn3R6aJvfl6ih0vCA5lGrQ1kINDTkZ3Rm/7eQE7LeKeLE62BXqFkn5++OYPISs+h0peHQ03BW/9vBjkV+rhVPiks4lSrtVXXsWo0TBrQlxuyM7mvrDZi3yW19RwR1sNzW2YGi83RAdKczEGUWUYE2oYdc/mauNdLcBQB8EuCmRJnWava2B45hl6Ma82q4tqu/f6Q5Iyc1m9qmN0khBDdmQQz3dBn+l0d/pq+ODOU4tlU5mZ1/v1s3PYg/0vJZHL/yB6PA22h4atvCj9g6bLHIvZ7bVX0oTRi25H9erPOGHvY67T6ULBUbnLi0QSCt7VGI+/9dieFJdsB+Pq3t7jnlQvYXrgegGOKOv6zisWRcSDuZjo6bRmBIUBfWBXmnTXlXPXpf3h//eI9unZR+Q7uev1y3ljdfC5TLJO8S1s+SAgh9nESzOzvfIFhHKM/EIyUNvQc/BxjyMhuLWFy77s5vM8dZOp2kqYtBuCXxMhAaLhdy28772JAQ0fFSpOTN1MCwYjBa8D2x51cW6LjjyYLWNZotdTGWbLhg6REzA0zp0xV49A2BAVujcLriWX857O/AXDLxrt4y7+Kh774KwDjyr4gwb/3En8beRUtmwmsh2VLiV4U9F3vDgC220JDPHMXPsL3JW9x6y/z9ujaj3/2D97xLOa+VVfhb+G9DqEw4nmdccseXVsIIfYFkjPTDZWbBrV8UCv938EP8eaGj7ni4PMB2N0ww+iD5CSKdIEhp/qGCsEej5XVKQ3rMiUHZuWMdyps1YVi4qPdWfTJvACNegsbo2dy49a5+csRgzl7+U9cndr6JQxURUHbMNV7Ym0SKY7I5R6qfIECfPaGhOSShqKB5RoLrhamp3eE/PpNeE2BNnibSUjO14Xyeyy1W8lTHJhr4+f8tEa1txYa4kK/qjb7DcWp9RA8GPipdctxCSHEPk2CmW7I1czNsq3OHXsU546NXUBNo5oAB+Mq+sQ9f6spVEvG707nP5d9C8CE+f8iXsffldP6M7aib8waOHeXV8ZdrNKq0WDwq/xT9zafOv4csS/VF9mj425Y0PLKPC2+Tghm9I7m83FSfD7qtFpMaqidl9TBZNt2Nvh9zZzZsc6u1nNbaJFzRjnjHyuEEN2FDDN1F0roJtj8d++O4+VvpG2/gDVVZ8bcH2+ZAYARrtiVhRvFK+bX3+NhlCt2Iu0DZRU8U1pGqU6Ln8iCfAqRr1evtDwLrCMNV5I5oKHdRmf0GlOnWgM9WtqwXpFkXw0AB2h27NG1lfDihE0KFTZVQWTC78FWWdZACNH9STDTXWhDN8EEb3WnXNKh6U2pewBOf/PTjhuZNaF1mRL8zd9U49loMJDrjd1T4VEULs7N5uLcbL6p/S5iXy9PEUV3DuPvVYHP5ijneij4JeIYX8LeW5BSo2gwNLxlk70o7nF9HJuCjys1Pk7rncN5ufEXDm3Ouq1LmP7CKH4xhCdSt+1zdygxxgL3Udd89l9GvziBKz75d1c3RQixj5FgphtKcxXvtdceajwRgEGG40nxb8Aw4m7Sh94JQF7WwIhjh4QtTQDg0kU+j2W8y0SiKZmUONV47++VztcNFYSbess3NfjY3WR6+h9GHfW6KqrDZgux7l08YT0haONXCt7bfjGbANCotuC2z5JsbDEYWGtqX0Dx09oPKdK3bQjto/TIhUA9SvuCzq7wXfkLoHXwc9X8rm6KEGIfI8FMdxGxhtLeuwG9e9b9vD3jCz44+18Y1C8BsDYkAJuMCRxpC117ccMNOpZSXfQ/rXd3FfPixb+i0Wp5ZOKTwe23My3q2DNqPBzVpKrwupy1wcejXJE38RUmE2f0yeXrxGSg4RMadQaVShqdodhVzqpmgpKtDZWWHUro91iq3bNcmVxt299bpS5y+O/d9L1Xe6ejKcren5UmhOieJJjpLnyh/BSN2nw+yp7QaDSMzOqDRqNBQwEAc2rqgvtrldTQ4zjTqAF266P37dDrgkUAdZZQUvFWvS3q2CVmXbNTqudUQ643+nPY3dD5ss2gh6yREfs0rtqo4ztKvS/0HgbqOydfp68uk5yGz2Co280p9S0XLjy3JjKAstM5wZ4QQuxNEsyIuBr7PsJX1t7WzKKO4VSihz/+kZ3Z6msbleghqxGO0D/X9boRONW2DRsp7vqWD9pDfTweMrQpcfef6WhffkwsJb2Pw9/wn/Dd5VXcXVGFRmn+P+kf3bMjnuu9rZ8eL4QQ+yoJZroJvUYfXPjR0MZqvV3BQccnlp5vDc0SesF4EVqih2kyG3oq1huNrFn3FVlqaPHKh375R3BF66L8P1j26JkseeeRuNdbs/lX/vrcZO5/bU6LbVtavq1V78GthAKwIv2e1Zdx+V2UNQzn/Wo2ka/v2ZUWDm749/9wafRsMSHE/k2CmW5Co2gY6An0VnTWL61WE8iPeSItNbgt03RA8LHR1x9VjZ2A2kszOmpb+BTi7LAenrSE6N6KrQYDOe7Id/pUWmhacanlv1TESH49yWoPPn519fNowhKF/zD6eOOnBwHYufBRDq39ionr70KNM5y18KfHWKmv5nXvcmz25nt1FtXnA7BLr6faF/9YjyaUZ+RV9iwheVPd8uDjx9NTWWBJQW1hana9KXKmVbYqgYEQovuTYEbE5dBE3xifn3U3UzIuYVzSWSyY+TSPHLEg5rkvnfwQMyzxezT6ZvXj3oFzuTr1FC6ccQsjXdE9OScet4DTM68MPi/Whfc8xA5AwvNo6mINufgDAaHdU83byUl8nJQYNwCY4E4JVhT2+pufqaVRQkHKGlP81cN/M4TydnzKnvWwpdgilyZ4LzkJtYXk8NqUVRHPbbrKPWqDEELsCySY6Sa8fi8VWi0jXW4siSd3yjX9Mf555CSn8eRJc3nl9Fs5MLsv04eOp48jFYCBdaECbAPSs3jolOsw+EK9J03zaGZNuYTLZ9+NyZjAqf4RUdcaMeoI7jjxiphte6S0Gk2MIOS+XulxrwdwjBpYN+ktcwV390pnXpxqwwDr04+Nu685BnNe3H0rwmrdpHkr4h7XGpPICCYAB7WQM6NpEgR6935x5A6zumG22L1hv2MhhAAJZroNn+rj28QENhoNeM2jOuWaHkXf8kFACf0B2GifHLXPrQ0LOJq5cea08a46zFPCI2XNBwMHeKITcRt7WKoJBQG///EjXm90z0u1MX5Q0tQA1x8AjCodweDksXGP66sEgrbNO9ag93dcr8iColL+tnVkVCXkpuyayP19Wi4NFKHC6qLO2caTwvh9PlZs+BGnyx61fff29VFDflt3rqOkItAD5W2oGl2t1VJTXxHMf+oo1TY3Nfb4Va27k5qKEmorS1s+UIgeQoKZbkKrMTCuJpVxNakoms6p2lqt690p12mPVOo52u5A30yOyIXl30Zte4GveX7Zl2w0hKooX7z8Wq58cWrUsRucX7a6PUrDjK+Jmj8wNxn+CZehDOKjH1/g9B/OZ6ux426cRlVlMOXNhjKVNSVRy0j41fi1gppaX1TLofd+w6T7vqXW3r6A5vZXzuHCZVdxyUtHRmxf/sQF9H75cJY+dUlw2xe/vMJp353D7E9OoKh8B7kFpzKuvB/Dd0/izLemcu4vl/LcR3u24nijnZV2Dr33Gybc+y3FtY6WT9iHFeX/QeJ/D8D8+EhKCrd2dXOE6BT7dDDj8/m49dZbGThwIGazmcGDB3P33Xe3mOTYEyUlJNEr57/sdN/FSeOHd8o1zz7wEhRvOsNMM5s9Tq8JrBadY1nUwivGv9X+npAcfJzm9XOGEup9SoxRW+6wAX2Z1ScXTwuLSF5d2aRSsMHI5sKfo45bbKyL2mbwhK3M3cLwTaMcpYrkmj/i7j+kZiFbi39v1Wu15A93ISUNeUTn9M6hIH0rzRVU3FK4Jvh4XE2gvoy3DWvNbi2z8rjucZ5R76F054Z2tflXb+DmusYUGci9rl/CCX3y8Fs/C20sK0IhsBL65h0r2OyYyE8VV7KhfholDcnfWypWtasdTW2vsDLM9CMjzV+wcUf83193ULFjPXrFh0HxUbGjfb8nIbqbfXou54MPPsjTTz/NggULOPDAA1m+fDlz5szBYrFwzTXXdHXzOt2jZ4/r1OtdMeFErphwYovHJWl34EBDjbn5NaOaCzt+NWmh4cv+wvOXkmAKrQw+p9TEE3lOklxJWI2hwnA79JHDYBafyrkD3uWZwsDCmNdnZnJRRR8eK9zJ3L6BY/3eFI5zqNQ6HCw2x0/UBZjp0PJ7YydYK5dCuLdXOte5tnNQnP0eXyGpyrBWvVZL6tTIHoTH01OZo/rRtDB1P9nnZ3ti4HOsa0MV4m31K5k/JDAb6nlrIRB/OK2tyrVadut1ODWhoLGXJplfd+xipX8w6cdOAX7rsOs15fVYqevzKbVaDeWlg4Dxe+1ae1uBu5jzBwam/T/gKqFzBqWF6Fr7dDDz66+/Mnv2bGbODPQMDBgwgDfeeIOlS5d2cctEuGQflO/hvySLJv6QltKwfpBG1TDS5WajMXZgUUsyo3a/E3y+JMHINvP/UVJZjI77AhvzryblwC3keXwQFsv0jbFQt0Vt33Cep5kKzT8aq7lY14dkn5/6hmUilE7uaXQpCm59IHK0adswXFSzOviw3htdtXlPbDKYAJW3ktIiFrdIVFV8/gS0WgNTsv5DUcpusmoH0LiwhdrKHrOWFO98m1rtPt1R3Wp1YdWoSy0Duq4hQnSiffq/3sMPP5xvv/2WzZs3A7B69Wp+/vlnZsyYEfccl8tFXV1dxI/Yu+aVu3i5qITvdu6K2nd9Zai3prlpw4N1R/BwkZ3ni8rQNrlBjVACOSj9lHKGu5vPM9H5HSQ2JJEqZUdRpf7OkWmvBfdPUtYD8F5K5ErgZ9Z4uOWb+cz+z/GMXjCaWa/+lU3W0Mrcp78zl+eXtT6HZvGahfx5/qn866d3o/YVZ00JfhKHORw8EaMInM3l5Z5PN/Dk91sjhlU/X1vMze+voaCi+WDilm/mc9Lrc1lTUhDc5jcEEqLdYUnA9Upi01PjMrhDv8t0vaWZI+PTxSh0COBqKAPwS6KOV3/bwW0frWOno5qFiQlsNQWCw5UZxZTqNazttTN4XqwZa02tWvsat75+LCvXvNquNnc3eXqp6iz2P/t0MHPTTTdxzjnnMGLECPR6PePHj2fu3Lmcf/75cc+5//77sVgswZ++fft2Yov3T1rTKMa73Hh98ac5t+QY+1dMd1UwyeVEp40cPvpHr8CsonVGI9dV1cRvh5rACmM9LkVBp6oMr+6DavmIxdk7gsf8W/ck+TFmEaVr6vho97/ZnhpYkTzf9wvP9Qr951HqX8x/1t0U99qn2lIjnr/768Ns9+XzytZ7ATijLlBIL1nV4jT1op7AyuD/V1HNlIbKtuF+3FyOafG/0Xx7B4U7C4Lbr3xtBW8sLeTxb7dQmxZ7AMHt9fLR7n+zw/Mt9/30v+B21RQdgOTYJsZ9T/FMdDhJ1cdfsqE5TaeGB6mBzzrTbuGWD9fx8uIdfFu+jRuyevFYHyu1les4wh6dmGs1tLxExk3LHuBDTyk3LH8g7jFjzUMY3EKg3F300qUypIe8FyFaa58OZt5++21ee+01Xn/9dVasWMGCBQt4+OGHWbAgdqE2gJtvvpna2trgT2Fh/JklomMMvOBJlhx4K94/fdDscW+d9FbcfWNPu55lY+5i86yP0eoix6ycYSs9l58U/xoPTn6QP590JxcmHM1DRQ4eSPwXmdrIXo8rczPYpkYHM1WtGGJQNF78vtg9C1rtMMY5Q2NVh9UlM9FVz+D6QE2UxIbeFT861tR8i6INBDAFej0FuugxujJ7CQNTvmNC4lcsWf4SL3x8O06Xnd6GTUywvEtVbSmqEntsz+8LDR1trlvMgi8fiWi3RlVJ9gWCikRv69fL6ghJcWIZgzPQm1BZeTxTsh9l5OAbKTesDO63O0o4py6Q5xNxo044pMVr7m5IISrVdlxRne353/HlT3fjcu69xUvbqzrnCGrUQI+b0bqzhaOF6Bn26ZyZG264Idg7AzB69Gh27NjB/fffz4UXXhjzHKPRiNHYOVOXRUB6Vm8mnnl9zH0PZwRmzQxxwQEZB8Q8BiAhycKhp10bc19e+SiKMteR4YFhB00lcWUfbLroIa1pA0djMBiZe9bj3PvUeuZrCynT6RjndLGqoeDaRoOB6PJ88O/01q0e/eVvrzPjiAuitn+acRFW6480ziZK9et5pLyChzzHALDGPwiowKfoMDhCSwpcnRMIJtY2eb0C21rey0kEEsH6PgCuz+woAz5no1bDFPtu4BJiCw1LeXSlPFzyEkk/mskZEKgDlOhXMat+6tEwzrcmzmvEt95owOVv3zf/bC9sNqj8syoyWbyvUs42YLg2n5XppYBCuscADfWArBWFhA8MNk7JH2SIl2od29K13zBhdPuKIYY748dr8CgK11Zv5dJZ8b9cdQWrz0qFMRDQajthcVUh9gX7dM+M3W5Ho4lsolarxR9nLR2x7/LswZfiye5Acbyshh6H6yfcQi+l+W/kB4+7mLUNAUx9WI6IXwGrt/1d8GU1O9mx+w+8nsjXKHMvZqs5cIO1Jw3Aoga+sV+l+xCAlWmB9+BQVI5yRxcjbCwM1yivPvob9Q7MwSTVKm0F+rLVUcfEU1FbiNYWmmpe1tAbpNO1PphRPYHeJKtGw25ndEG2rTvX4XbHyKQO47H+ndUFhUyrjUzi9jUkeRt0sWfEldQV8kBDYKxTdawoKGRFQSGJ/vjJ1o2mWscFHxdXbo95TIG7OO6K8BW1NTg9kT1yjSUBCqy7W7x+Z9tp29zVTRB7UaWjEp+/9bMQ9xf7dDBz8sknc++99/LZZ59RUFDABx98wL///W9OPfXUrm6aaKXR9YGibKne1hdna+ok1nKU3cEhrkDOxBmjj+D7P88n0xs/qD3h8PMZ4QqML4TfpLyKwipv22pvhA9rPFzxJpd/cSrbHzwsuK3WWsVm7bPB5x6DhfeTy5natzfvWSJvkDvMg0hQDMFhnuB7/GQGS9d+E3x+kJJBepMhLYexF709gZt3X08No/NfjG5sM7N7knVJnGC1BWdRAXyZ3Loos6JoB4ML3ws+d6cNjtj/77eu5NTvz+VPLzWfg6Oi4gGahiAFDZ2pq7Nirz5epzrY3bAquBr2Z+vgkjdbbHuJ9goUdyoATsugmMfUhs0AcoctfPrh98/y95dncNRD30UFNBBI1N7XmKzRvZaiZ/hw64dMfXsqF395cVc3ZZ+zTwcz//3vfznjjDO48sorGTlyJNdffz1/+ctfuPvuu7u6aaKVNI5cIPBtur3cg67l3lI7U9IihxZb+m5iinPN3YbWTYXW+iPrtUxwOJlVb6VIr2NJQqhnoqa8iNeKSiKO3WLwUanT8lBG5PCVsckq43eXB/J3XBqFNfk/RexzxigIONsayBvRAnVtnEqcok/m7HprxLbBreykKs1f1+z+lTWBcgkbjc3/Vmy6cg4a2I8L+yXEPWZ2QxsT1FBitF8bOXR8V0Yaowf241NtQbPXa+RrqL2jxqkX5DGmBh97TaHZQH8ULcGpczLc/C8qrNG9To4YAU5X07uar/ckuq9vVwS+NK0oW9HFLdn37NPBTHJyMo899hg7duzA4XCwbds27rnnHgxxuoPFvkdVDYy07Vlq1sRzbsZyRxGTLrgrYvuw+lAOzklWG5omvRLT8ma16vUvq6nl9/ydvDHoHrI9oR4TnybyRjXTauPj5EDmRplWyzdLvuTQF2cz+5urcSpKMAH45e13sskYep2J80/n9IbkVR1GCnzlwd4RbVh+y3+q3+fSZw8LJuv+tSYyufSHiuf5oqEE2qdJidzVK8bssTg1a4YZYtfxmVLXulyhUk8lN2a1fcqv3V7BpQsO5ZKXDsFmLUFv+hiACl3Lf3q0YeHqAttXobZoLLyTEqgY7W0yO+qp9//Jic+P4qHXLwtus/hWoTE0vw6WM6lPnD0Km80efIbIACHLGui9sRoGxzpJiL3C5Yqe+SgC9ulgRnR/7qS/YbTnkWfK6fDXDv9WnOrzoTTpybBaYlfazW6y0vTzqRb+k54KwDilX9TxWw0GjrHZ6RN23nqjgW+X3IlTux2foYLPE+PXa7FrNrPaFAjAc53bKPQHln840OXirozIFaCXmKxsyF/Ocve2mEnJOyxFUdsiqSgonF1XzyhXILjK83ixaBLx+D1sb1I12aY0XwW5UYWnJuK5zloc8dwfZ3hr3aYPWYKTpYqL1Rvfw68EfmfjK+IXSaxtyJOL139mU0JDlsf4IoOQN2s+o9Cg8IonVC24Vv9c8LHeURb3uo003tAimNN0w3i7qISLa+rweEJDUbtcwxpeO7fF1xOio9idEszEI8GM2KteuWwK1856kHsujC4et6dyBoXqrLymTo7KF/HrYufplMaYCr3UFDj2gQs/5pFh/4fOEzkMclFtHYsSQjf+ZWYTv5hCU6DfS0kKzpiKZWtDb6LRHyriuN5ojCjf36iubBfrq2Ov3+TXNJ/8vmT+P/C4nNxSWc28ilBvQvXmz7jj+79wd6/I4GmibwVlu/ObfU2ADF1kjRqNJ3LVa2/YCus3zz+FO18+B7/PF5Go6FNVJllTuLWiigxr/OD2h8TAZ++LEyAp6LizvJI7yytJQMfaRR+x5MlLKNyymurwfKAtgandKb5QkKtzVMV+zbB2muoiP4/zc7OZ29dAbfWmuG3eU6rfz/8+mcPTH56Pp8lnK0QjTSsS3vdXEsyIvcqk13LIsFFotM2vF9QeblOoRoqaugZ/k+/yvRJaX6X2D6OBbc5d6HR6jj/sXJJqbgvuyy06gqu5gAWWUKE4vzcRn9r24U6b0nyOxeu7S9Cs/II/lOiqwK1x2O4F/PHzR9xnGsf9Dfk6RXodc1M3sdIU/a3ulswMtn90f4uvm5HS/HpSFjU0u+xTzTbeVdfz44oPKaoJXbOoxs5wl5mz6q2kuiMrMB9oC3yWBn/od2gl8phGZtXDaVYbp1ltKIqBtEVzcFk/ZcXHcyOOm/dT4Hd4fZWZGVYbBzmdmDWxA9yk6o3Nvr+mDBmB/Cajt+WentbYuPljHqtazlO1a/h9zSsd8poA9vT45RCE6EkkmBE9RtPV1M8ZPYXZva8j1RPoUcnxeuntzgruH+BuMltIDSV4jvbuxNxQAmBCvyn0ypyEu3JKcL+rbAZ1pvYtlVGbPKT5AxQFN6kxd91ZFrtnodHniQmUOIt5OaEva8J6isze2HlLWwwGdnpanl7sSG0+mLHpp0dtq1HMWNImBJ97fCoapYQ7MtJJyPos4lhfzTgAMj0t/0nK8pfzf+ZDuScjjTWaan5ISOBvOVl83mShU7cSmt7+UHklC4rL6Gdqflior8fDCPOA4PO1vt24YvSeNerl6php0E5X6N+S02Nt5si2STGkt3yQ6DaSGiplN85qFCESzIhuy9gkj0Np0jOj02q559g5HEYgcbVEp2NGyoHB/f08WmbVx75xDPYX4Gi4iZ02vjdzDp2MtuxoNA0BU2P9mLZK8eymupk6N8vMRsoUJ/Wa5Ha9/s1Zvfhv/R/oLZE1aI4pDgVQfZpc/ouE2MMar6z8jvNfe4HpC/7Js7+/TYY3FPxtL1nNqc8fzuEvHMV7638l1VsRdf6Ha58jIWUoBmcgUdmeMoACk533UpJ4OTWy16WKwPu1Eeo5iZczs8Wo8klOKW+lJLPeoKNWDQxLbdZEJuPqWugFiyXJr6JVQr2IFWrzgYVB7Ziqwo3vdYDbw5EZ46L2f7G2mPu/2Eh5ffN1fMINcEFewsAOaZ/YN5gagpmZ1o5d6LUn2KcrAAvRnFRrqCbJn2rr0MRZdDDRYAE1UJROowndqHyKjpk2e3CGUrg1lt0c5nCwzGQizZKNZ3cBrxvuoXFy+LnOHXzozaFSF3o9raqS4/UF66HE8kVSIlnln0N03TwAHk1PY4zWBHHiHY3S8rTyIkLTNn/esYt6Xzpv+EP5PjVNRvxKjNFJzwAPLLsfRVeNonVR5ADC3us7FR9Ragj8Yb1zyY0c4z866vwVmm0Ul23GgQEt4NMn84El9u/IZgj8ca7R6IFAPaEkbLTU91VhyuGZXoEeKJs+cmiuV0Pw9VyqkzJdNtdW19DWFaWcxozoojjAsoJCPMAay8g2vmJsxbWB9+xGxxJlLIeH7fP5/PzzzS9A68Sn1nHLic3X8rGmjoAy8KpazDWbgX144cldy8HjgNwxEGPtMBHpYFcmx1oLGOxuw2r3+wnpmRE9gq+Z1ZP/OvNhztaMZ17uxejC6owkKkksSzsx+NyWFsovOP+Yq0hLmMDVGWcxsPcIDh5/CN9nVOJvmDF1cp9cTrLZggtIAvgUpdlAppFC9IKJ4ap9vdGroWhmUNgfrlszW7+Y52inC4vfTx+lgglJoRW/rU2CGb1Xz6pv3qCiopjnl33J00s/x+lxk6ZUomhj9wSU6kN/OlRtDR7/FzGPq63ZgNZUHHNfOFtmw+wjfSh8yarpw1FWd7OLJmrUUO+LisogR+jN3VZeA8AuvZ81JiOX5Gaz1dH8WkUbjQZ2u0N5MHWJA2IeZ1JVklUVQwf9CfX4QkHq8h2Rw2Wq38ufsu+EwU+zprrlRHq1YaFWk8aBthWzt9rD7Xbx5lf/5re1X7V8cBx+v59l71/ChjdOhdK2FbLcX61ImkOi388urSzZ05T0zIhuS6vRBivnHeSK3/2endGbWy54GYBHfngF6j8HYFpdCmVHnwvrlwNErNZ9/IhJHD9iUvC5Tm/gxdTQN0eHRoNWVTmnJoF3W/i6f6LVxudJoanbHvRA7Pbm5J/GBuehjB78HgUN27Yb4nTjtCDfoOd7Qwa7TW5essQftsqzriLjt/d5bM1APsoIBA5bq64kWbFTG68LqYl0v5beHi/ZPi8rTKGhopr6VcHHemcllUoaUNOq18xyJnNzvZ0XMrTB2WBNaVQff6qt41VLCiPdDi4tSuLRfuURx9dqUoFAnRmf2vLQU4235fWMShoS2psmnbeXK7kvAEUGhcd/e4/Z46+gf3rg35uqqtQ1DHnq1NZPzd1qMLDBkc+YDmlhpGc/vpnnbF+jKVL5ccAPpCa3vffnkz+WcYvFD5ZcXi7fxfj+e6GhPYwbG1flZGH0qyzv6sbsY6RnRnRbsyddSb+GL+2W7EujVtuO5dyDZgYfv6c9lNNHTSZXcwS52smcduDhzZwZ7cVUC78kRvYI6WIUrQtfTRvA30wv0sP+D/jIeGPwiKdKyhjaTM9Ec6waDdf0TuTBjLSY09Eb7UywcmLf3sFABqCodhe79PEDmQG1kVOrT7cms3BXEVdXRxb6Swj7vmSyFUHYe1f9fmprCiiv2s3DpdGzt9T0ZbySrlDeTKXjXOt6qtyBQECvKvRTonsiajSBWV1JFYeQnRs9HNZUauro4GMlLPjx60MB6XH9enNcv978aOiYaru+sNc293mNVbtCQ4U+1RccCk13NF+JGcBk2/vrRVXpB5Ht9TLO5cJhbV8ifOW2UG9hQX3zRQ1FQLk2kN/m9bd/eZieSnpmRLc1ctDBfDao6XrTzctLScfvsaDR17JVOwiLKYGvLnim3W3YbIi80Z6/ZRKe7G94Pawn5L4mtV1q9NHf/K+oruV3k5G6xDreSEkm3xDIcfl3emqwl+GsunreTondwzKjJIcvckpi7gMY6PaSb4j9n3thjKDl8OJXWJcWO4fh5ooqnrKeDZa3ADjM4cCh+HknORGdCl8UlDFjQGDW2OzNL7OqVzpbDXr0SuT1r3l1Mj+oDZ9FdiZNfd1Qb+Y4m50RLjd/GGP3zuxWewG1eNFi1lewtaHa8YO9LEwOO67cORy9KfbsnsSEPoyuN6HzJJOcPja4PbN6VfCxaozugtuua37IsL2M9e0PSMaSwheFu1GAikEDOqxN4XIsJ/DNynkAVMmQR6dJ9HwERhhcK8Uam5KeGbHf0egbeg8S3mrTeVkNFYDDczh+Sois/Puu+Ux0/rZ/R3g6zUJv8ziuzMnip4ToqryX1NRya2U1SpzZM44WhoM0fj3D7VoS/H4SbLno4oyONM7ueiNO0ASw0Hk8Rf7QYoyn1Nuwavzc1SuD+zPSUH3JEfVinikt55vCIkaaBpAUNjvoZ1o3I+PrxAQeKK9gYWHsG/wf6YE8mBqtl2uyQ8MdjflL+oZsamO8rGogPfd4ft11B4tK/9GqNjVK0k9q+aBW0DlDPTw3VlYzOCGUlK1VtJzTkJuVqLZcr0mn6Ojj9dHb64uYmSW6vzyvn/FOJ9nNLLK7v5JgRuy3/No979o2eCN7FBb/33FsTw0MVzUGPYmu+EsdhDWGuy58h8NdqRGbG3tlbBoNV2f1Qo0zm6k6NfZq041t2GZSqSmfydSUF7jliJc4sDz2mkL1DbkZ9VoNfTyxZ0xM065ijPmXiG1fJASG0hxNarKc3TuHS3NCtX00YTkmGlr/jb5Uq6O314ffFZmbYbFuw6ULtNOvsVIUNpx2YEWgNk6eNxAEDcx8h7qqQE9eQVUZR80/k0ufPQy3O9D2/sa1DDUtZ+nKFzjjubEc/cJhvOZdFny9+vln8ttrd0Zc31Zo4M2HD+a/714X1eZPfnyC0QtGM3rBaA6ffxZbKuInQhvsoYVLv20SzCqKEjF8+e7X13H+/IP4ddmTcV9vb0uzbuIXs4lfzSY8/q6ZWfPC2hf48xd/Zl1Fy0NvPcUJ9mReLi7jdtv+855bS4IZsd+6uKZtY/2NNVCK1NCMIpf7iIhjFI2GJG/gW3aK389Eh5Pj3aURx8ytipFn0bCoZZESO8HzzZTkYJn/WBrXfmpOaf+P2eF+k9zdX5KVGHt4bkPYUE68nJnShGpKs0Lph/l6PXZN4LyBTjhxsBm3JtCDVK3VsiksgTk8FHO34dvl+8mJfJ1gJlmJ7M3ZYQzNmy4w6NGrKveUV/J54W6WVF/W5Fioqw0sSfD62m+p0vzBEpOVRSs/RvX7Mfd5lZKB7/J+7StsMvop10fWmBlGAZO2/Dti22zD69Rpy/i18tOoNn+9+b3g43rNRl5b83Wr3mt1C6uh31n0NWs0Hh5e91zM/bvcZYwe2I/RA/tFzMzqSBurXuGvOVn8JScLm6d9NU9StPH/PbfGf1b8h5VlK3llQ8dVTN7XOanm+L55XNK3dWuq7U8kmBH7nYkOJ0Pcboa72jYTxaYL3DjtxlDOS39/YdRxroZibStMJp4uKeOuisiqvXY1gRPrQzeA54pL+WVH4HXCW3RldU2b2heusUem6SyguaNnsdq1NZiPclBVFveVhQreNZco3Og1SzJJYYmxz6RZqNQFhp3yY+Ql1mi1nJ+bzRZXk88qzrRvgH9UVkcMVX2ZlMh12ZnYDJE5KruatLdcp2OW1Ua2BzzUculb/+APY/QMJn9YT4ff72VX/kvsNgQCsL722MsozOiTx1l5kYnPO41e/pueyi69jo+/+7/gdpvLiyYyFxqfPzp4e/OrR7n5xVnU1IaG0LYZDBS5yiLOe7VhKQ1n2ChjZZOZWVVlu/nh6bN4ueDR4Lai5Lyoa377ywM889GfqKuN/rfbmYYYetO/offPbY7OmWqJuSGAvnrYOQDYrCU89/EFLFx0V8c1ch/jB4p1uuBsOhEiwYzY7zxeXMsHu0tI0MceammLPH/0KtaqGrppHdTwDTncVttEljgDqakjXG4mOF34/IEbaF7Yek853tZVsD3K7uDEJhVBC9XYN4f05ExcamhYYJanDHsz5fpjuaimjlvDArR+LpVaY/Oroq8xGXH4XWhp+T1NtKrMttrwt7O4boFexyfJJjIH/IclzpbroOQYIz8rvz32vwu/orCxSRLyBqOBN3cXc1ydyrzCTygtXQPA52uLGceOiGOTrAVRr3lv8Yt8qs1n/a4PIrbbfaGgTQ37/bjDFt90KpHDdJs+fIBP/ctZbwxtV5skXTsd1czd+hpP1qzmw1/ujvk+20rV71kPC4DX3Pr6SaGTGoLhNW8D8MXih/hv9SpuyH+Helv71jbb172bFOhNbm6Jjf2VfCJiv1N48pss7nsZeec81q7zD7SH7rLrkrcGH59fG+ixOd6dwew4yyQArMneQGJmIMDp59SyJPt8Kk55A4Brj/lP8LiKVnz7GmM1MN01nFnjH4rYrtaMjTr2aHcWw/qPYaS+T3Dbi2lwT6/YM3xi6e/28Y/qGka73MyrqOLmiio0ZcehU0IBUl+Ph7X5O/loVyjQG7rrCNIzJlOsb0UFYz1M6d8HrxIZzfypNvCHPDwBO9ZQ2Kw+edyRmYHDEP93kNgQWEx0OEnQmjnQNJB0X8uB1ihrZADxbWIC92ek805aIGhwOAJDiHa3j0cyI3OljO5QAOiwV/Hb788Gn//QirQqAJsn9Pm5myQDf6Cu48uk5l8ofEXuuj24Iarh5QX07Rvy8BhSObA+gTG1FiztWEOq8ZPwj5wFgN0d+n27NB2zzMS+xqFI4m88EsyI/c7wQ47msEseJqdvCws+NtE4m+kcW2hYRht2b/7NH6ggnKmxcE9FFTdURufGmP1+rqkrJj0pcAP41H8YYy5+nKHjjgTgwMGHBF/z8fTUFtuUN+RyTp77GUccfgY+Z2i6pjt7UdSx04acBUCKJiH4XgxNYov0Ftava7xFpPn9nFNv5avEBAr6fsNOX/T1Gpl8WlbUn8zC3x9p8f0AFBpj34iGd2AJd4M78nejU7SkNQQz63Ii84n0YUNSpfYDaWp12IKeNnf8DzBTE5rafcv7s7ls3RPB501vvt7wKeRh1x/q3RL39d0xZi4ZbZE9h56woa5Nvj5ND+9Ui3UevkhV2aw3k6tLbfP5zobP7I7FgZ6Z0rB1q5yetq/L1R34ZXZaXBLMCLEHxuuGBh8nNOR45E69lHXGceDMjjr+nDoref3+jqFhkUxD2lI8vsib9DXlrV9McHhtQfCxxhhZZybZ1/Iw2t+qIov69a87vdnjCwxa7ktPY1L/Powe2I/fzdFJMoV6PWfl5TC7TyBfQ48HPU6q/LuCx9xYWU1SjByS1gjPA7qtYs9mpC0xm6hxVYE//rTtAWGzunbRfG5HnTNwbGXhExHbk31+hulCweZXvppmX8djTMPpauhFCcuNCa8zpFMV/D4fXk+g7dYYM920rlDQ5vP7sIetFJ+mjmu2Dc2JWNTV176ijn78qBovwzQ7SKja2O62FFgDU/PDAxirq2euXVSsj72OmpBgRohWcykKY5wutocNbeQkD2Rsw3TqtRmBm3X/EQcx6uYfyVRqo15jfmoKE8+6gXRH6Bu2u8mN9CxrHWvzd8ae9RRGo6qMVkJTlU3+0H/Ow1xuFky8kb+nnxHc5m9YrqHYW01ZWOKsqSHH5/KEY3n573dwgDP+t9qZVhtvWJKxtTBEEZ5bUq/VMKH3Q6xOCuWB3F3+7zYvBNB0XaqZVhsaX8uzuFoyZ+P/cUP+3WxrCJJGNVkaY0tY8GRJ/75Vr+mKsYr4iC3Pt7pNdyz/C0e9figf/RA9YynHHfjkrizTUXjvWOz3DiB/w7Ko48IVW4s5+p2jOfPrc4LbUnW9W92e5iiulpd/iGVY8ngeLfRwZ0UV3lYsMxHPDFv0qu+KPfrzFz2bBDNCtNKB3nTWGQ14TaM5yBmaQu2Pk9S6uplUAl1YkrDWEzlDZ93gy/CrCr08gTVYWusgVyBn4Jy6et4sKkGvicwncVkCPTXblOar1pbrYg/zpPh89HK2Lz9iTUrkDWdsysIWA6KWfJdg5seklrvdz66rJ8EdaLcrJfY326KwBULProufa+PUta4XYowmMlCo12r4yNz6PA5VAbtGw4od30bty/bCneWV9PbV8nZqPS+l6Sjf+AtGJfYsLIANO76jylmF1RtKFD+o6LVWt6epqoQ9T57PKV/GYzlwap/cFhcAjcXc0LM3zhVdziBRt+dJyfsir9K+ddr2B7KcgRCt9OzlP1NTX0FlwVY2/3JBcHtfr8paY6Csf7i3LfFv/NqGSr5n1NVjalIOftKf78Zpv5HZCUkcbavBbEzE6nFzwasHUxBWs8WvxL45jnC5g/WAdUTf7K0pQ6Ch0+eDFPjNHNnOVB+Ux/jLoMZYU2pi8lksqX873tsMMvv9wYJ6WlWlrtdSaGaNqtZwaDR830ztnUZFpqE4NV7AgUsx4Pf7g1OzJzqczK2q4dzezc/GaqteMQKLd80+/tTwON1lpMrY8nDiWKLL1p9or+Y0q43lWhMvW1JI9vnpnTedEvsO8G+PPLjhfR7ij+7BKlWb71Hx+7xotLFvEU59aottb4lmLxXbm2m1YdL2zLWLMrylVEk8E5P0zAjRBo2rA99QVc2LxaUcoO/LOdZU1ubv5LmS1k8HHahauKimjsMcsYvkmRICN8PkxFR0Oj2p5kSuLFN4qiSyCNoi7+bgYxUNqT4f76Qk8ViahWpPLWNMg+gXp5IvwBpD9LIFmd7YfxbqtRoWNTncoE+CVizfYApLj/EpSrCmS6cIS5p8aM21jH1lLM9ZQ4scbmmyKvkyU2Rw2TfG55e765jY19LE/ixy3SrZ9kBvzb/f+lurAhmA+qzoHKYUv58rsjP51uIj3eejXqthh2dXjLNh4MoHWP7Z8/hc2qiKzis08f+9fvvLA0x4eRw3vDqlVe1sj92eco60O7ihsprh5gFtPr8xON6mD/y+6k3RNXV6GmMbVk3f30gwI0QblbmreNGSwpeJCZjNffAdeBoeVctq06EtnnugM3CzmzDsdK6qsjHQ3YeExOgFDGNxKfBecuQ3/rEDpgYf55jH4gfWG438L9VCnSdyuMRYVwDAlP7jwG9C8VlQ9ENpyk78b7X5xsg/GUZv5Lf7ofppUecktjHR967ySjQxVh9vL63qIYHovAoIJAA/1mTW2Mdhn/GszUczwxp97hZ77DWZvImBG2qRPzJfKru2PwXemwHYVRF/5ldTNmNW1LafE8z8nGBmk8HAmIbk7TJnAR5iDx8mrF7Ajqro95BO/J7DD7Z9hEujsNAXO2/L7KmKub0tSr01vNrw35ESp5exNb5PCPwbTEmdxniHi0S/H3cXLbGwt2n2ILeop5NgRog2qk7K5vOkRF7THER51uEcMvMyPDfkM+afkQXawtch+unURfxw6iJevzSwDMDoKbNRbyxg8M1L0LSymmeVwctaYyjQmOrpzfGHnRt8fvdF73BEzhVR52X4fGR5vRgaZk0dOfAAfj1vEUsv+A6TJvqG5gu7rxzscPLS5I/4W0Ef7t/t5cwmOc3p1s3ownKGnjr+hpht17Qy3ffK5BOZNXcn353yDfeW7/naWRCYeZOsRpfcT3YHvtFXxfn8U30+TtX+youpkcHm6AWj0SZtjnnOvA/XUVBh4w81egVzRYEXP7kYp8bB38KqO0+I0zsH8PW2WdS/dU7Ets8aaslMCMvbSrTvJssZ3aZLc7NZZHZS4q2Kqsmzy/Eb1VWx1/Ry+2IHoL/9/iyLP7qMNHt+3DZ3lRzTcFaZDLydkozV076k5H2dVm2hdsJ+TIIZIdpoUHo2qqrg2H0+2SmB4CIhyYLSJKF1vCdwExzu0pCakkZGSlpE4GJKSGp1IANwiMvCydbQH+m+iQOijhloOSji+QZfBSoKR9qdDDGHkl+TjWZMegNpptBsqOzUgQBsNYTex9RaE4Ny+vAfx6VoHb3J9kf3Ipkavi323TEDc0IvBjbJkU33KjRd7HtAnJoxmekHo9XpyEjN4fMW8mHCi+c1R4eG/p7oYR2d2vyfvxqtljmDnVHF+wDMee/EPKew2s47vxfib1J5d02vHRjVKv6o3UaK38+TaanBfUtjTG9vtNVg4LfS6JlKI11uJtud7GpIXE5wlqJTY3+mbyVb2B02u+qAhtlaeuDn1S/GPKe/Pfa/y9fWL2BL6UpKPG1P2I1njclIgbbtPXFZDW83uSH6NrqrGeH2MNLlltXC90OSACxEG43I7MPDh79ExlH9OWRA/MqlD5z1Ph///DzHHnxO3GPaot9fPmXE8vd5tP/BFJVt5JywXplGWab+aL1GfDoX3sRsSp1+VpmMxBvoee7k/+OV38fTx13BrCmXApDo6o9DF6j78alvIhclGvjo78fjKB2MZfUHPFTyHP/MCgVBh9s9eDU+dniS0Gh0PHbCm1z+5VmU6gPBwgNTX+Bviy5t8f2Nr07HcuhRwee/JDQ/c6rpulOx3FhZza7sqzjB/Qe/8U3EPkVro6O/zyUNfoS31h/OIUNHQtWS4Ha/ouBLuhUz/Xg/rEpvms9HdQsB7f+FfdYAeR4vbxeVcLdyAlsNG1rRqlQytKEg9OKaOhYnmPnFbOK4XoFCj+X2cj7Z/gljUg/km0XPke+wQFJ9cMZQI7ffx+N6B6fZ3NzprCTH6yM5cc+Tp6v0bU/YPc1ayzNpFhIahiSzi9/jropKUvx+9Ma2VxTuDhIaAvCEdtZo6skkmBGiHU4YdlCLx2Sk5jDnpFs77JqpvXI44YQrA09GTox5TFb5r5gVN1ZA1ZkZlnoAN5d4GKrWYNBH37gtpgSuOiIyyTTbdgAViYFgxq0LDGUMy06G7HEs+eNrjgibtWXUJfBIRWBV8LfU3wEY1PdADtUM5lMCQxEj+o/HgQEIfJV+rLScx8J6JgBGV/RnUfkV/MUQurFneP1U6vYs2DjKbudl42gs+jrMttCMKoCqFl57ms3eqtlSTbkyfmVleQkxJpKxraoKLKHns6w2Flgie7smORxRM8zCFel1LDKbWORr3eKMetXMAH0OFp+PWq2W67MzSfP5uKymDkU5GoB/Lf8XX+R/ETqp4aWdRAaMVpcXl0lDusPPaTYb7/mOZLgh/pTw5vh1e7bys6fhA95mHAnAEnUn/+idy5j6BB5NaMdaT91AYzDzp9qeOYy2J2SYSYgexG3fiTWsy/74EUOZ5fNxqNPFwIzWLQCUroaSPvOzV0fsG3HcHNbnzeGv1UnM9A3kT8fOY51uODdnZrA5ezUuZw0Alxx7Hyd4+3KV5WQMBiMuXWgI5BCni3Il8M35nLp6ZtosjB9yLTdMH87EgaFv1Dnl49v8/sONcbowqIGFP6v8tohApjXGO+L3/DxZUsbq/J1RPReNjP7QrLPksPyTwsS6iOMaA5m+YSu4u2MMax2y65CI53/LyaIqI/J3E6/UvcZfzjJNLrlho1DVWi1fJCZS5/RSVL6DBE8SR6YeQrYSOV3Nr0QmnBboA0N7T2bt+Ww0qyWUfK7xtn2Wzm/mQM6T11vD4jULMaIjy+vF7Ns7t7XttdupdHRMHld7HeRK4qbKKo50NF8ran8kPTNC9CBrvaFcBo2nHv2On9C7AzdWRdO6PIKT/J/zU8OMJkOTon2WtF4cdumjHBa27dvc0RR5F7HeYObyhtL2Q/qN4l+XfB7z9V/KOg6PfzcA0212cs96lt6Dotc8Wlk7i7N9dZSnb+DnFoacmrq7vJJbMzM4tl9vTrd/xRp95BpFl1fXYvH7+VdGWtzXqO5zDDh/jLlPAzyeZgkGSG/vLubxtNRgOw9xl/F1w2rSmT4/9dpACnS83qDw9ag2KFlAKOgZ7nKTmrYIiOwlcptqIp6P9+Sw2BB9s91tKuK/u+eCKfL3v9Zk4Hz7Li74+DLKdArzKqo4TlW5LazSstJkiQSnotJYH2hS/z708uQzwVlDRlL00h1tYWqYadcW602BhOZU1nD5yhv4v6pMjMkqmxMd1LiqyUqOrtHTXj/t+okrv70Ss87Mj2f/iHkPe5Xaa2XSVVxYfikeVW7dTUnPjBA9lNZeCbljYeAUGHp84HErPJwZ6pG4MOnYFo8fMH429YqZw7xZZGfELpF/GgcEH+dra/EYAt3ky01GcvuPiHnOHadOIsGe3WwgY3T147TKQHuVhtyJZJ+fGbbQ7KUq988Y9ZE5FMfa7VSq0TV2WsulKPwY1q7PbbMj9h/SzAylljib/FWupXU9ar39bR8SKyx5hzKdQrrPx1hXdJK01h/ZmCFhids2jYYdRg0eR9cuHbDB2FBnxl/OLp2Oar0P1d76mk+tUVhfCIDD66A2zgywzuCmnvPzcvhLbs8cRtsTEswI0ZOZU+HCT+D8d0BnbPHwpq4587EWjznyoFm8f/ka/ntZ/HWLbv/T68HHtRoNasM3/gUpqXFndJ07oR9HDusVc1/fHTOo3/gAP130MXde9ztrL1zL2wc9xatFJTxfUsqqsQ9wXGkOR9vs9FV70avv3zA19DIlb7uEGXULeN3XcqAWz9zszGAC8l8rXAw7627qNaFkmPt7hYKn/tZAD4ERN9OtkVPEcz0xhqn0kUNRJUYP37SQu/OOYxHzkptfn6mRxRcaOnrS8TWfFxZxd3klr6ck81pKZICnb7JUR2rDsNpke2CYI8HvxxhWbfeH3x7h8PmjuO2Nlj/b5Op2LC65+k24vy98dSt/rY5e+6yRojafIPvNjm84/OWDuPvNE1p12dK6UHDq8zYzi05V4bWz4KFBsHNJ/OPaqUobuLZHBlWiSDAjRA8yqv+RGPwqaV4/BwxquYhfLPPKAn8w8zx7p6ZFhaEvY+sCvQ0japtfBThl4CR+KyhkYpOejkI1kxE5yRjDhm36DBhNH5eZwS5IH3wQo+vS+E9ZBYf6ArNtNKhow4rx1bTQ4zGyz8RgANQcp86Fz13DQamHBXuHwtV7+wYfH22PzHWI1Ts0weFkpKvlaeepYb+etqxzNbhJJeACvY5H01P5MDmJTcbmZ4hVqoGA7QSbnbX5O1myYxdmXSiYsWz9juOtNn61726xHUo7Ctt5fnoYl7sO76+PR+37ORHUVhbfe33t/6hXPbztarmdAHUFK4OPK23N/G48dl4v+YUrkjV8tvLZVr12W+g9HwEwoGpgh792dyfhnRA9yLETz+TzIYeTYEokOTG1Xa/hJtCDszcXHPh59zwsJeX8rm9+5ebRU2azI/NbXnjraPL1Omb1CVTYvWbGeOYcPBmNJtTKpJQ0dDduxOf1MCAhhZ+bvFbppocAePXqyfRONTPvu8381Ewh27HDprDwwOPQKDo2bF7D3HVX44wRNLyUmsIVhS9x3dlPcGbxFk786rSI/bVKIEDYrdNh8fv5a6WLZzIaPuMYrzfLamO21cbogc0HejUt/PVO8PuxtyLI+SYxIeY098FuN5dUR1YO3qlLAFx8Yk5ntjW6EGGmC/xKINjZG67OGcgvyS5urLZhbzJdbKcuEYhuUyznZp/Fssp1JLZyIVeDt/Wzh7YZ9PycYGaEq67lg9so2+dkgNtDlixrEEWCGSF6mHh5K61VrGQB5VSr7Zty2xoH5qWyvkjDrFHR5fqbMqcEhmx6u1X8rl5ojBUkGHXotNE3apM50NvicNlZmfc7K+nFKb56ynY8yrAh35BtS8Ni/pK0RAMJ7uZzPSyJ6SQmBHpO+qSk81xJGX/Oi11TJbNhNe6+uUNJ8Gqx6wLDM4PdbtzJY4HfsGs0/DUni/5hX+xNuGiaqfJ+ciKT7Q5m11v5KLnjfwcrTJE1Xd5vco0sr5cynY7JDifH2CJb59QHhnaWJClsqg0k4Kb5Q0NR9ZUu7rLv+VIH8ayoLwYNPJgW3atWq1hobTDz2epS0BPRU9ecoUrL/04BrC4XGT4/M6w2ens6/nd3ki2NB62/sdEvq002JcNMQogIP6QE1nSyG/bOt7/ejk3Mn3MoT5w3nntOHdXi8R6/h4+SEnktNQGNrnXfdlVV5fvEBL5PTOAj4048PivFegWvLjTMY7HviHv+E6PuCQYyjca73NxfVsGo8sgu/nFOI6dPCy0jUVkSKpKY4FeYOW5wxPFupfkb0UaDgan9++xxINNSr0y8wmt6FQ6rNfK36loSFBesfRcajg3vrTujdy5n9M6NWDrgO6OJ5y0p3KkLLVCZv/sP7n9tDt8vey+4rbJiM6vKPmvzexpQGVj7K8O7Z2t3HVAbWB9LaeUyG301aeibBD5Or5P3VjzFslWhKsoun5un0yx8kZRITXL7c7Li8VLF2XnZ3Ne7dQuV7k+kZ0YIEaHMkAI4aOXf+TZL1JjJSjZx0pjWrXLs1vi5pWG6cP+abHakFpKkb/3UWDXsjaxLclFbvZm+6eMwxKpqBwx1KRx1cOTspFJnOTfnZuNWFIodkecNTxgZkcRsIJQLUqXVkdAk8bpMSQUCs21MqovaJgN6ba2Hk+31Uqpr+5/yPK835vDSbr0OxeTiJ7MJLXDMe5dASh70Pxwt/rjVpAG+SEplhy4Vs5LE7Q3b/vXZ5fxkrOaTtUv59dBAgcYHF17G97rQUJTH1LqKvRN8G9hIYAkNRdWhKtDH42GXXo8WL63N8iow/gFAbRuWE2nqs+2fcsfapwFYMmwWCQm9QB9K1C5OOiDeqe3mRWWD0YhRKgBHkZ4ZIUSE66c+Qn/9MVx94EMd9poarZa/JE1nmjuTOVPvbNO5A3uP4HzdoRzrzuWgvLkclHwOM4cf0vKJDSqMfSOeu12BoZKjNINZk7+TfxWGbgz93F6uHBtdtdmtelhrMrLJaKAudWuz1ztACfX4JFdfwHhb5KybkSmTW2yzyafEXb+qqeR23tiK1PjTexMrJvGP7EzmZmfyQHoaOKrZufNnPDHuGGpYzZUqTSCccKStC24rpgaAeq0GaneBvYp17sihKE9C64ZxDvatCT42NcxYMjX0mOiUUKFCtYW1mTYb2rb6dI1qx9MkubimoUAkAJ6GXsywY+p9pa167dI6JxXW1vW0fJoY6AVztSLg9at+tpasaH72VQ8iPTNCiAjHDhnLsUMe6/DXver0h9t97k3nhy+IeHybznVok4HQkFmyPjR8pIT9b6bXy525f+eQiWdGvUZqWnPfsiNvcpt6h6bkWg2Ho9FUc5zNztcN06sPMCezzh773EbD7UYKzK0LUnK8PrbGmYSU5fUy1uUOXjucR5sIRCe2JjstrLVPxqguQVVUXrMkk7rkUZ4k9s3565IfGZw7CABdWN/IslUvcui4iyOOLfrvGAwaI4PTLBQmBIbbDrCaSNJFL2Aay5sWC+Bit14XnGnW2LtkC4tfVHP8YogAhzl0bDK2/ia/wh+oMzPUZiS91+jAdcsD+Tmz6q3oNdFlD0ptnwMzmn3drWX1HPvvRWg1CotvOpqslObXqKrWtD4Iu/e3e3h78zvM0GXw0Pk/tPq87kp6ZoQQ+41jbXYSdZE39t5uWFi4m9eL4n+TNpl7cWlxEqOdkd+gB7jh6DHRC342uu64YQwYcyT/LqsgvaG+S6Itfq5OkL6Wv9VU06/JNOosb/RASryign53BhfU1rMhzoKcemL3/NSoSfz9uMnYtt4Y3Oaw7o67dEOVM1R12OIL3YwLytYCUKcJBSrT+/bmlrRETP5QILFZ7UNvY+uq9W40hd6/U9P++XYD3IFeqaRWxgZmxUQ/t5cMjx6NErht1tWGetyszoZ2hS3L0Mu+vcXXza8IRLU+v0phk5ljDmctby26nbcW3R7r1Ba9vTmwsvsX3q5dgqGzSDAjhOjREryxi6st8xcyemA/zhuskOz3k+Nr/s422mbg/LpQT8ZhrhQ+uWwth4+N/+37uAOySUpJY5s2lDScoIS+xR/siJ2YtNpkpFCv47lCN4m+0DFlbciN8ew+mxUmI7v1sc/p5Q/d5Pq6Q4GB2aBl5uhcfN5UhjgD27M98XN56netB+D99Ysp0IfWi7K6Ajd4L5HDWUvMJhaGrRw+Ur+eZ9dcz/R3p7OuYh3tNcTd+p4WpxIIAN2tHJxIG3AT67c9zNfFtwS39aoPrFi+U6/Hpzb82wmb2aU0m10UULTrPZJH3kTyyJuoKYksJmCzlnBP/vvck/8+G/MDAfBug9SXiUeCGSFEj2PSm+jrDgQBRyTn4msYBvjNbMLlC/Su+M0DgEBvx/VZvZjQvw9LXVtivp7DVozVsoWFYcM1hjizksbVBnoixtWkxtyfpUkJLXfgGRD3PazzD+QI13+xEt3zcpjDwe/5O/lLnCq4qqrBq2rZ3EyidPhtXBOWJG1Q3SiuOi7SLsTbsErzNl/sKekA3rpAj9b3y5+I2F7ekAeS6IrsufI2yT35v8pqfqtfQ5GtiDXla2iOthUBAoDiqG52f0VDJV23tvWFIafn3c70vFux1uY3bAl8ZqtMRuo91la/TjifK7TsgtVRErGvxh7qOXvnp5vb9fr7EwlmhBA9jkar5Z3zF/PulJe58rSHqEwNTAG3ajRUu2sASMw+F8PmazDvOJfFZjMOjQZ/nClctbVbmJeZwQ9hwcwpY/4W89ifim4iccvl/FT8z+C2+3v5qIoxc6ZSEzmLJ70ytOBmRpKBX246GqVJXo3J72dNwa0c63qUo2oyuKs8chhhbG0K1i3zuH7a0bxz3s8xa6kMdycy0R77z3+2r5Tymi18OuQ7CsyBnoZNxpZvFQZf7MJyub7iZs87Py+bm/tcwndnfse5I+IP2QFo1VDPR9NhL1dYkJSgab6S8fdJbV+7aVmKk18tHpzu6PIATX9H7dFL33yeD4BPaX3P3NSGwoWaVtbS6e4kmBFC9EiJCckMHzi+2WMqfXk4wv4KWpP6t/r1U1NjL5AJGkq8gwj/81ra5B402ONhjNNFfZNZN319kTk5vVPNoA3Vxunr8TDJ4WScZjs71WweSfon5iY3q3Xe4eBLpHeqmeTEVLS+6CUTanS9OatOG8zj8YZNU6/UqqiqP2LGzOrksqjXaFRhdTHxvm8oq4usS/SKezHvfPV3prm+jXsugF9ReHTn87j+dThbV0cOtdTVFnLW/HGcPX8c1vrmg6JCfaCnbITL3eKq1lWa5qeCr//jfU56cTS8MweA0t3PBGczNeZcNQYws+qtWIyW2C/UgiXlXwAwxukiQ58a97hpSqBWUWob8l/Oqg/0Fo1ow/BbdybBjBBiv+JLDtS3GZ4TuMnXeTOD+9yGlr8dA6TZepGQHDvwOefQwFTwP00KLUeQYTs/+LjAV847yUmUaPXUhyWxDnNCnSv0mim6AQCcXB+qavtOYTmPlVayTc0jLUFPdaqfG7KiF+PUKDA4M1B0L8UVXRHa3/Cnv2G9T7LUUA5LfRtLr9Rq3FQqv7LLXBO17/6ir/k+qfkgBMCp0fAbmZT+/nHE9nWbP2ajxscGjY/1pSuoV0KFBOPl8ExvxVIKJn9gKvjlVbGP/XnjO+zQwmcFC8FVj88dGAKabrVFJZDvULNRza2rk9NUvRoIXm0tJDPrG4Jes9q6Csf7I5maLYTo8dJrw1ZobviGfeTQTJb+3zEUVtv502dfoUtsvn5MuHI1Ne6++08bzd+mDaFPWqh3oFQ5gjTvK1Q3LIzpVxRURWWkrwS928NYl4sPdt3HmUeMpei3kWgVD7pJRwMw2OMGEjm8XmWS6xl0ePn77MM4/aA+vLdhEf9qkmaSnm7m28uPJSMpkCeUbRtFReKmqHY6FJVKXeAm2dt4DjVFa8nPW0y/GCVPhjo0mL1G1iQ7ovappjLMKe8Qa3EIj6KgVyPzUga4PRQYovON7hxQDyyEBQu5NOUArpn9Br6wXiefOT2iBymewx0OvB4H7s//j6U7alkz/BquPHp4i+eFS9WkMMTtprTh81ntK2rT+a3VuDTUNoOB61dfg3OtlnFKKg9f3HRlsYCWVgMP1zis6VT2jz6L/eNdCiH2azpf7G/gWSkmzHodloY1fQzu5hNHg6+XtBWXPfbQi6Io9E1PQGmS6DqgPpNxtckM6j0T4+arqNk+lxGeUXy0u5i7KqrwaBIZ29dCha8Ppd6BpCdG5n3oVA31JFBNCsOyk0k06kio2Rx1/Rzf9mAgA3C8b1HUMSm+aubmhoYfVJ+WPyk/AWBWYhdwU/yxv/vGqiIc7rT6yPN0rSgt/ULdBrZu/4rdNaGhq61lreuVOLt3LvbCHzEsfZJy2we8u+zfbCiJTK7NacjjMRN7CKY68Wo+2F3CxbX1OD0+dqiBIn+rTUY8Dat9N76L1Sm2iCUdGtUY+7TYVl/YTLUdBh2lOoUvtdFJ3evVQJK1Tm39SuONVbO3xwgceyLpmRFC9HgDNaGhGI0jsvqs12MjxVCEDYUkaytqwDSorFwJQ4a06tj+ysvUaxyUVU5nxJAjePSiQ7C5vKwpKGHur1q2qXm8deUURuamwDng9vo5cXSg9sorKYHZURs0mbx88QTsbh8TBjQMa/ijp5Mn+yJv0L0pBCKLsZ1f52PdoL+wuORVUuv7c+rM6ez+/B4gA3uMb/JbzH4GayuB5gOXWI53bEWr9sXXENy1FPw0clt6k6bZGXzud9aDJhA0HOJwss5gxqmNDoyyvV6W12/ltAGN1/yViup8yAnNyPIrgdyT/6SncilA6QYoXQ8jZoIhAavLGah8DFzmcWL0g1UDJTod1e5a+gI2Yxa4AtPSfY4aSM2IWM6gzhBZ1bjKWcVPaxYwqf8xZGePAaBemwLEDqBVQ+i1dqsxZq35vKCVW3gj6ZkRQvR4/TUZwdkviidyqKSs5GeK9c3nLJj00RV0DZrWf+PNT1jMmhQ7ibkfAoEhrhNG5WI0JfGhfzJr1UEMz0nGoNMwe1xvzjykL4nGwI2qcSjIZdIyZVgmJ4zKQRMjx6KxzkpSkwDnwcxQ8GBq+AxS/RoOGnA6mwtuZ2nlRSSl9uL2hm/yBQY9Ok30TXJbjCDkLxUuLihv/jZSqNMFA5m2KLO6ydP3Cr4vpXIl7oZLnWS1cVFdTdQ5Ex1OXtrppl43MOKahupNUPYHNKzo7VSaBEHPTIb3L4XfngRAxc9rlmResyTj9fsw+KJ7hUyWqaEnDb01Jp0ZT+1YAHRNqgLfuugmbtn4ItcuDFVFrtJE5ztdVd3wvsKSmG3GQGBkUsOG2f74JOrccE9tTWJF/k6mbDqp2eN6CglmhBCiBQeNOJKT/UNIbAgGJjkc9DbFr73SVH9/YLaLCvjCek7OOrQPZx7ch7tmH4hJHzsfZJLNTZrPR3/nEa26VtNibf5W5JkATLD5SPT7uazYRHracE6qNJEWo5Bg+GrbgxxGDqo3098Tf/jjxL6tW1C0qUqbHW/YVGynJ9Q78UnNRdRoo29fv/gPZLLrcco0kb8b56r/svn5yVSteg2AVF8g0Mnyeql310PjdaryWbHlc34tviZ0slYXTJgG8CcFXjvPGJpG30hRFFIagkmTN3Lo6afi3wBYT2AYz+moxqdEDn/FU5cQSCbXEQiqL6+uBVusLKWQVeowdvuzSVdaTojuCSSYEUL0ePWqs82rUYfTaLXcN+cDHsm4gm937uZfZW0rET8q7VAAtptUyop+DG7PtZj515lj+fNhA+Ke+1Cplbvye3Gos/mgxKCq/Km2jqbrPZ1fEehxMXuMOBs+g9WG6LyYi4tT+W3HLrbUHY+qT+CNsjvIKjk84phst4I97HNUgR8sHnY0TIt+vLScX3YUBmuc7Ik7f7+Sf+5+kt0NVY/9YZ0pBam7eDMlesq5Xh/7Bn9dgpvT++QybfPzgePUwLBbmU7H1LemMnpgP0YP7Mft1Zu444fr2KoP64nRmbAr0VO9Dd4YhfK8Lk7WLgYgx/ZHxK7w1dvdrnpOfONI3JrYtXkA8Efn84zwpHBZTS2HOJ0UVDb/Gf/uH8YATSlnan9s9rieQoIZIUSP97svfi7MxFHHMcyloY9HZcqYM5p9ncHjpuNUcyjVDKPP0DEd3cyY3vMdyQGaHThi3FCzco9mgAv6ulW0vmQWJiYxYfDpEcdo1YblNNVQkPO7ycehA9IZlJnI+H6pDMlKijgnL9XM4YMzMHqabLdmRjy/qS98lBG66Sb7/aT4Vf5bVsHCwt3cV9Z870FLSryVwSBU7zVwTVUNAJWZK2MerxpqSRjwJF7nrojtjcUQ/Q3DS56w4nPusKChyBt7tpCVxKhtA4rfjtyw4mV0D+XhUDTMsNo4zttkSnxYMFZVtZVybeyhtyfSUgFQnKFAR9MwjFXZ5w7q3Hl8m5jATzXN53dt7b2I0QP7cVde21YI764ke0gI0ePpNNE5L42SE1N57/LVcfeHy+k3FG7b0O52THA46W+OrvvSnHu8F3CP9wLGGlOj9hlNWazd/gAAL150CEePyI46xqy66O/2Uat4afwuP9hjIS/VzHf/mBo8LkFx8Ye/L32VcrQahdcvm8TCdf25afFSfIZ6Jig3cuF4qFz+T27LzIi6TqNN/j4M1+zihwQzD2S0r/5KLL2s2zjQ7uCbRDO1Gi1WjUKtVss5dfURvTRacyGJ9ZHLUjTmz/RpGA5zN82ZaXC4J4+3DU2qAzcpSqhxVgMD+ImCiO0vF//OvwaGagudGFlDEAUVtaHXTG3FjK7wNKPs2sC/T0WrZ32Cj3VJyZzvj72URaPapMB08k3N1w/sMaRnRgjR42UP+Acmf9eXddepatSU7ZaM75cKwPEHRAcq/TISgje9/hnRvQcATu9QzqurJc8Nl245mLX5O5nmzIo6zp15ICM0hRyTHnkz76UEbpoZniISU0cxuz7+8MbCxATuzNEzemC/Dg1kRrrcLLevpFin5a2iUhbuKuLcutAwzwxrkwTdFuqx1GpjTz/fnnJq9Ea3DS1hvRvewLnaJrfP0rAKyP/f3p2HN1Xl/wN/35s9aZau6b6wU1qw7AUElMoiIu7CoILighYUFRR1HHT4MkXn54LOKDOOIq6oo+IIKjsoyr4XkKVQWkr3LUnTZrvn90fapGmSLlDaBj+v5+nzJPeee3NygN4PZ/mcW40mjCz8HPhPBnB+p9cty2rcvUEaPxuc6qQ6j4SJAFAnVGF/7ShYK4aDj7rb53UNGgK39hjyCwQUzBBCyBXmEMtbLuTH6oeHY+OTo/HY2O5e56K0Cux+fhx2Pz/OlfG3qfdE9+D9yoU4kPdnMHD40j4G29XeK1yGPLYS5+7ahGue+Mp1zC5YYRA1JBkMgyUoFsMs/8SCXD1+yL+Ijy96TmD9UalGrrx9g8a/l5RhfI0Z36mDkBkZgY+azJXZJZdDUZqOsLPTWn3PKt53pmeTWOfzeCjzXj49Dp5/HsPF7vfnJBKMiY/F3UIevj/zGwDgzWLnkFsPq9Wjs8dQn9xO0oo9lMqq3oQsfBO6C5WIUvRqtmyM3Rkk3XgJwUyNrQav738dn574tM3XdhYKZgghVz2tQoK60wuAk08jPnZQh39+tTYZAPCbUoFSS9smD8vEIvTUq/326ESo5dBr/AdL1yQEI8feE2FaHe4Tr0OG9BeYfOSS4UUiJCUPgUjsnn2Qd2E1auuXgYdJgqFRSFAKHRbXPon/1d0IaZMH8KxSHZ4p9c4SfKnuqzZgYo0ZBWL35OcqEY9nQqKxIti5QixXKsHnqkics1wDroWA4EL9ROUEy3if502OY22onfvPgymCIePErtVuh+QyGEU8jstkeP7ChwAAWX3dfKTGAQDX3k/NCbZVQ+NwQI9mJg63g635W7EyeyWW7VmGoprWrbjqbDRnhhBy1ZvQLxK1t41DpEaOMI3vHoyOUuNov4d9a7x8cwqGJoZgVM8wjPnROVSlF/4LoPnJzgAgtjl3iB5YV4cQiRa9ojX4x5/SMPezg1hhvxlWRxkA92RbFcwIrY3B0XMHkNpo/khb9bBacUYqxQmpFDOi9Dgid+ZsuavaiPd03ps6RqvDMXNEMt447XXKi81SAw371ec5o9X3yp8VBRbcmuicfFJrLsH645+DwXuoqmFwK8VigQDguEyGJKsNRVXnsFatwg01ZtQVTmm5kgCMNiO+VzcaOnTY8HB5Hm7lKqG3F+NY8UYAD3ldZ7E7sO1kKQz1E6d/l0pwXW0lduxfgT6J1yE2dniLn11ndf8dtTh8D8l1NdQzQwi56knFPO4aHIfRvcJbLnwFSBoloRPLW7eZZXsJV8swa2QSekS4h2dUjopmrnAbouyHw+fysLKwBCKJFBzH4ab+zrwxRiixTTLGVba71YpEwYGV/G1e9wmzeCaQm1e/KsmfhizBexVyVyADAKk+doC+vlqEO3reivtHJrXqO63esgDbg3J8ntPZSlHjY+WSirmHgd44+DIW7P0bFuJHzzo7il0rr7JlMtecnlCHAyvWZ2JtkAobVUqYJbUQWvF3wN4k+aFw6DPk8lV4JDICt8RG43iN91wcAPjPL+fwyMf7cULmbMMPdFr8e8M8PJnzGWZs9A5+fLlwap/rtaGytJmSXQcFM4QQcoXNTJuIKNEo9JJPxsh+YzutHskW5/+yY23Nr4Rp0Gv4jdinuxF7w25Ht5R01/HX7xqA8cl6TBt7F9Iqg3GjsQ7z8kMQMu5VVCrO4QOt57wWMTw3m4zwM+m1JdYmQzFLS8uxuOo8RG3Ysyjf3PywiYHzzl/T2DHOx35OFhNyRf6/U7HgnhxcKzUDYpnfsg2UilCPeTQOwwW80MwqsgaHL2zEw/qnPY79Xr8/UwUPmG1mmG1mOHxshdHAbnb//agxtC7w7Ww0zEQIIVdYrDYEG+55t7OrgWvNdTguk0HGWreiSqXWYej8z72O3zYwFrcNjEV2QTWeW/Os895/SkOf/tE4d+zPeEPk2fMg4/w/OGWCgH8Wl+LBKO/VWk0tCfNcIZUjEUMtl0FosnrJKI8AmiyNbvC5yf/u6OdFtXCIq7yOvx8sbnZOiwxAlboXULPedewf9XN6isQiDAjtCxQ6eziCVdmuMhLGsDLPjCCuBnbegTtio6B2OL+LVBGCbmW9YFXlQxqahN2W8lYlfixh2dgZ4rnVhtAoKBr22TAAQDdNIh5NywRXU44hUcMQEuLeZ0zJtRxsdTXUM0MIIeSSiBrtESWuf9AqfMwlMTd5OK5j12BJqXMitLhsNM5a+qC3xfcO1s35QKfF4/pwsPpgidUHHDkwtPleAHBB7F13kUiKbSrnBGR9UbrX+ZuNJijF3nmMiusnUl+QSHCm2D1h94LMDs7qXHJt4zj8K1SGSDtzTRBubF/ZbBw5/xJMmjQ8WryxVd8h1JLtdayg0nue1llDLhZuX4gF+5bh8e89V4L1l6ciSGh+eXtXQ8EMIYT8QawNcs4HqePa50HVW6/GfekJuC0tBiN7+B8CCbakeLzPkwlYU1+XCl6CSqbFxMvIh5JRnyyQOZxBk4SXoWfhYAysq0Nmw8aNl6CXWQSbrQYpxkSMLguBVHWqmdL+V1IZat3B1RgjwFndwc0vQWLcmBCGv4R79jpZrSZ012xEd81GqCpatyVBZUUORD62QdDVFLpeLyj3XmZ+uEkAeiFqPOzMGR4wkf9dzpkgwFDVttV5VwoFM4QQ8gdRIHH2FlSKWrf5ZEt4nsNfp6bg9buvgVruexdxsVUNnc2dpC/RagNnToTZFgGtVQ6HOQkfhYrwti4UYkswjCeWQdTMEuv+td5DVlE659J0aZVzi4k9Ff9Djv4gFpdV4G6Djz2UWsksqcP4H6agSlqJn0qfRnfm/eA28TwEJmBXwdt+71Moc084zjDaIOHFHht2VohEOCh3fgdj/QaaZlMhSmI2oyRmM0w13rt2N7XsyykY/f0t2Cn3/r49LHkAAIUgeC2n96cWzsBQUPkf/jv0/25C0Bvdsfur11p1zyuJghlCCPmDYT7yzLQXMTyDjQSrgBiV+8HNFU/A71VTsKfgeVzIeQmOml6IDJoAB0SorXWuSHI0Mz8lysojzs8u3Slcruu1wDswNTYaCyPCkGT1Lt/Dx8ooAK5cMQCgq399QlmNmyL/D9s03uW3qJQw2IwIauU8pAuqagRLdfhPYUmrygPAcba3xTIHavL9nvtvo0SDax0tL80+YfgFXH2WZJ7zH/gq7HvwtUaJC7ne86o6Gk0AJoQQ0o4YGieU0/NlSNSJAD+jSO/MGIgbUycDeNR1LHXVIr93N/JqAN5DJQAwS9EDRfZCFDZK/Ldb4TuhYI7E9/BJ436LbJkMu3PzcUKkwaw4dwC4pLQcLzZaWfSXA0uQ38qnabFYjMLjv/p8+CbUyqA0eefnsfmIk84rgnH/h4MRI9VhybQNcAisVd0T2eHeE6CbBnaKCmfw1N0UhEil/73ElkqH41DYeQw1y3C731Ido8v3zCQmJoLjOK+fzMzMzq4aIYQEFMHqfADrHVFX7DPSHM5hiWvqnP+z/02pgLjRo0awBuPuwXGu97HBbdsJ8SQfi3xxkyGt+t4DqaPKI5DxR2vjMbTWdzI4c5MVQwzA85GeuWcaApkhtXX49GIRDlUcaWXtgeUhOvyesw5r1N75bI4VPA6LuRueWTkUq7c/7jo+zsdIWa5pL/ZxFnxnK0ZR0UHYWzFht5bnIfAtlxvEhWPVxWK8VnUKYkOe33KHwp07d8uFzg8lunzPzN69e+FolJMgOzsbN9xwA+68885OrBUhhASemnPzoJPmwpQw4op9xqv3rcX6XZ9BOHYC2Ww97BwHmXYIEo7KYYUEE8feicfG9sC8cT1gsQs+95QSMeZ3qKlSdrFxx0/9Bc7gxizyzBFzt8GIL5rs5RRqd2Dh+UgkS47gmUgdfpf5n+AKAJ9r1LhYP9fo7aJS1PEcFkaEAQBMTIV5lvsAfNnsPZraLa3EZonvfDYySTl+5GvRzVrnekKrfcQfFxrtF7Xp0L9b9bnBFjkqZb7XrG/L34YjpUcwo+8MaHklBtbnJMoX7N6FBQHY/S50DgFVIh7pZu+szB2tywcz4eGeGTuXLVuG7t27Y8yYMX6uIIQQ4pMgR1VdH8SF+pj80U7kMiWmjnkQv5Qsx95jznkcW1P6ItvqnFA6qmc4eJ5DbLD3cubW4OHeNqCp3xvtWaQQBIht3p9RLhZhsmgPDtp7YFb1RSyqD0z8WR6ic70OdTgQbXE/3G28AClan7CvQQgXjljbBVyQeD6CQ7q9ihM8h0SrDRNNErzTyo3HXy39DVJRFIBCv2VeLy7Fr3Vj8XWC9/5TZ6RSzNsyDwAgMAEjADyiD0ctz2G+pRxxTS8o2Aesfx58vHMIKljwPezXkTq/b6gNrFYrPvnkEzzwwAN+N10jhBDi25ePpGPhhN6Yd32Plgtfplz9Dfib7V48Zn0S/bonYtltqVh2WyoGxLb8v3ihmUdTv1o57qtukkemPmleDu/OXPtIQQi+VEZ7FIu22XGHwYjvglT4m+N2FLFWRgv1fghSwsjzCLU45+GckTMUJX3bpnsAAIt4ASfO/D/0Kxzgcdxan7eHAzC00RwjB1NihLn5Pb1Y/Wwfwe49fDW8thY3mGvxkvCj17mmyg0XUOCoxG9KBQ7K5bAKVsBiBE5vAiz1413WGryr06CiflWcjPnJUNiBunzPTGNr1qxBVVUVZs2a5beMxWKBxeIeCzUYLi15EiGEXG2GJoVgaFLbHuCXTKLEB45JAID/4zlMG9r6jScZ57l8ONJuR1H9XJgEdgELK6ogZgwf1G86yTmcvSW97RpozRfRt47hOdMiqOOcE4lja+UYlz8Aadq1mK8Px38BaEw6bHAMAnAQgHtSb4TdjrfO85jW3Tug+kSrwWFxOPIuzgbH10GZ8H6bmqSpXVXToY467HXcxgE/BYmB+m0gDspi8JuydXl4QjkDKuG5AkkAh/VKBezM9/J5kSCCg3dO5zCc3YscVV/XuRBpMPDfB4DTG4A+NwHTPsWu4jy8E6xzlVkSpkVGq2p35QRUz8z777+PSZMmITo62m+ZrKwsaLVa109cnFcHGSGEkCssI1mPcX0i8MDIJERofK8o8sdSPAl2U0/cYTDiboMRfy8p8ypzq7EGw8xWpJVFQypzzj8xBv0JGeVa5BlHepRVwIp/OG7FIsNi9KuRIq0yGHMn3ohyeA+3lYjF+DTUf89/DuIg1MXBYe4JrknOlm51rcvh8kvpnzBU/5bf88ViMY43SppczbXcm6UTqgB45hB6ocy5r9IehRwL9OFYFKnzuq6H1Yr+jXqIzI3mqI6tMUMhkiPfWo3P1EHYVLQbgsOOM9UFHvewcZ3fL9L5NWil8+fPY9OmTfjmm2+aLffcc8/hqaeecr03GAwU0BBCSAeL0irw/qwhl3SttWIMUDEGi+WbAcBjVgpfHy8k2u2oyJuDA6yX61yJvBvusz0HAMhdNtlriXepPR6leX8FAPytdwRO1w7HV3nO7Lr/sN0Gjm0H44Dvdf6DGTPcgdk1VaE4GOzeiPHpIh6DhCI8Fq3FAbn/AK5YJCBSZEDmdd3xkY99L20chyMK99ycs42WkYfb7Sj1sWJrcXkeXggPRXWjYKauhekYK4pK0M9ixcdWob5/Ctglq4a4yRyYV8SR2B7mnI+TsCoN59sn52K7CpiemZUrVyIiIgKTJ09utpxMJoNGo/H4IYQQEjiu7xMBqZjHavto1HIcHByHhyurEW63A45glDENClgozrAYDEsKgUzsfJTdmBoJmZjHmF7hzd6/t14NfZPeImaJgNTY02f5xqNearkE4WoZwtUyOKyen7NTpsG1luUYXN7yppkAMDSp5V2wAUAick/aTa+tw19LvTMRn5JKkV5bh571OWM4xvCt2nOl2JxKz93S50RG4BeFHAOkBzyOn+SdGYe3qZQwCw78bD0JALjVaPIZyKjYpWdZbi8B0TMjCAJWrlyJmTNnQtyKHAKEEEIC1/szB8MuMAxYtgfLwoxgHMPhi4cwr6oaX/BpGGp5AQDw2cMjMCwpxLUgZFxfPbJfngAx79kjIeI5nFk6yZXOj+c48DznmjgMAOdYNLhqBZSa0x7X9q2Iwr7ix6Dq+yIAIIKV4+vnxgEAsr424Yj5RVfZmqACxJty0LtWivcLizG7mZ3Ag+RiZ9C1s+X2UDvkqJY4A5EtKiVOSb2Xk78VosO28xfAOOC6+FgwjsNZqfccmRib3bWtBQA8HxGG0UbP4bFSy3nX6521ZwGbFhCbkVZn8QqQACBI6PxgJiB6ZjZt2oS8vDw88MADnV0VQgghVxjHcZCIeAjqM3DIy2G1hWKlfQIAgJcHQQAPATxigxVeK1slIt7nalexiIdExEMs4p2BDIDgikMAgD5mEYbG9AOY9yPxoGU4BLiDAq2jAiKeg4jnIJd4dlN8qw6CVWqAHFYMrfOdlO9S3GAuxta8C/iyoBBJVpvf3DhjE2J9BjqNVcIZjMyucvfS/Kz2Pxx1pHwfunHOsbCuvIY4IIKZ8ePHgzGGXr16tVyYEELIVaGu8HaYz89GbcF0fBifg7uiIxGkFmPd46Ow8cnRl5yrpkFfSSz+VVSCqeVyPDepL27s617pFV1wLcy5j+COXrfjk9nDXMf5Rr05E1IiAQBixjDVaMLw2lpM6ZeAYnUBXmmUn6b3xUGIsXkmn8uwOIeY4v3sMwXAtRnlJrUNW5UKJFqAY6brXOdXFhZjYJ3nsuhHIiPgz4pgLcwSZ/mNqta1nVBTjYaOrsZbODRm5ZoPoDpCQAQzhBBC/ngGxIbDYe6JMJUWlRIHzvMarA/SoF+0Fj31vjPo+mLjfC9J1vEqjKitwz32E1CaCzBYcdF1TmJXwlGbhNhgFUb19J1Yj1M4H+52jkOvGjlmVxkwNrYHvtJo8YnWPV/TYI3HiotVHtf6yurbVMPWCvkSCf4aFooD0iBEm5yfGWOzQ8JYiz0x/uRJ3G3yf6XlmGTyvTO3rdA7yV5XRMEMIYSQLum1OwfgsbHd8Z/7hqKm4B5UVo2EVHVzm+9TyaX4Pfd0eCgy9eEoNZ71OJ7ePRTzM3pixrBm8uOI3HNP/h4pxlv1uVeM5bMQbHFPMO4dGYR8WzeIGi3lPhH8JwBNVhw5pAi26fx+3BPRQRDbVZhXUYWZ1QbcEx0JE3/5j/EzEgli7D62LQBQBityJa1bct6ZKJghhBDSJfWICMIzE/sgJVoDh6kvrGU3QC3Vtfp65nBuYql1TPF5vlQwwspxyJWIUcs8d47uHanB/Ixe0Cnb3vNhV6QhrCzN9b5fuBkHw/IRVz/UZDf1QqGyDwBnXpsGw6xSTA/1zJHTWJjDgZnSXbjDaMKtPnpSmu5+7cui8grcUu7ZU/WhToP/6HznsjkuM8LWQqQQ3Cg3TWehYIYQQkiXJhbxeHRsdwxJDMZdg9svb5gpLB3F0EBXp4E+0nO/P4e05bQenNVzFc9RuQynanPxwuS+OGMagb41YqQa5ZAq4vGeTovcRquL7hgc63W/Ws6KCP0tfj9vZhmPraFnMCYhFmuCVEgr99z9/Ez9kJO2upvfe0gYwPMtBz1tESJ0fs8NrXMmhBDS5T07sU+br1GiDrUAbjd9BuA2r/NSVSL25P0fAIAXefbAWINiWry/2GFBrM2GC43mn9Qq9ZjaOwJZ0yYg8zNnHppbenuubIrjSjEk0TnZOMbmQIFEBJ3DgdnVGtSofA9rhTgc+F/Nw1Bq/wUAOCuR4IwtBr42l6zWnvU61mBJWAgSrTYAvucRXYrzosR2u9elop4ZQgghV6VakbPHYJsqx+f5xku4Wzv1pFCa4HodLA3BjxcK8Y+iEtcxh0znvF+jqTA6sQ6Ly9yJ7ioV7tcl+Q/h04tF+Cn/ItRMBZ7jENFo/krDKiirLRgH0RvnpM6Kfq5VQ4NLy++S6yP/zOUw8bKWC11hFMwQQgi5KmVWVgEANILvDCkjuodiVI8wTO4fhZ4RTVZHMc/lRvK8OyG7MBVx/COuY4IqAqvtY33ee3i3UFzbMwyTUiKRFKbCHUb3HJdRZvdy6gpLL2wwTcVpRzf8qLkD6d09lz/HWp0BmRLeeWsKwn73+dkdTWdLaLnQFUbDTIQQQq5KtxtNuNZch1K+h8/zYUEyfPKgO4eMXJUE1O9pqag8CTTaC7q0ZhAAQMTr3DfgOCyyP4yB9mgAO5znrUYAQLBKio/r89OcPvorSkQifHSxCGqBIczmnmPSW7UVvwafwK66blDJkhGikmJEjQNrtM7H826VBOF2OzixHRLemSywKZ0pCvn5T2BU6L9wOOJcm9rocqkdAobVGTr0M32hnhlCCCFXpcPWAehrseG4dHyrykdEZiDG6nsy6/X8ASwWr8I1pp9dx0KDpEgM9Uw+JzMVNL0UF+qKMC4+BvdFRyLaboey0RJtdcQPOKM2wK4+ianXRAMAzlmSXedjrQylYjGiTGF4ZEw3OOC9OVI0572r+OUw590Pa/noVpX9Le8CRtTlt+vnXwoKZgghhFyVHrQtwADLe9iqnNDqa/5S6MDa/IvoIfdcNSWPW4U1CUdgsv/gOiYR8dj01BikDxrY6vuv1gShqtEEnZNyZ3BSIRZw20DPFU7JNRKcyHkFOLkQvxQuwtzrfW+EKRHx+H3JRPSI8N43CQBevmjHxxd9bM/dIP9u18tbjSYkajdBGrwDotqWN8z8Uh2E18LPYNfRDS2WvZIomCGEEHJVitEpYYQSafHBrSrPOSxIdlQjwW6HlPecJHtUJsVZqQQGvtbjuFjEQ6bxv4UAAFg17hVKb4QE44Fod0ZhVf2WBbpGy5tPVNyKuNP3oqDgIQCAUQjF0CTn6ierZQAAgNXpEWx3XhvC9JBLRK49p5qK48oR6icXzMPlZhhNAzyOxcpOQ8I5kCC64POaxvlsloSFoEwkwqa9//ZZtqPQnBlCCCFXpf8+mo6jF6oxuld4q8rn5X6MpxNDkGwNwnNNzn1xsQinJFIo+GYyAvvDez5qixolynuqogpLwkIQa3NPOC5nYSi3OwOeAy/egD3nKjCsPpjhDHejtqIfHLXxCOJK0VNxDLXR0wAAVapugPEIAGfA0ZB35ht1ECwch4GVoSgWiVCgca6+UjsE6AQBo2N5HKz/7KMyKe6tNmJYrQUzDAasV6mwJMy9ZxXgzmcjtejwbHk5RtuLcE6fgc5EwQwhhJCrUpRWgSitotXlRSIlUqwW6BwCKpjn6qFouwPR9lrsDvPuhRHbqr2ONSf6YuuGvcb1iUCISoqJ9RtaAkCPsFAUnekHMc+hyKFGkbEbpmudwYZN6q6bhbl7ltYGqaAQBPStleO85RqINesAAG+VlEJllUEf8QsO1ncMnZFKsTg8FL0tVlSIeBh4HoNr67BP4d6eAQDG1NTiGiNgrOmPSHEBOnbasTcKZgghhBAAkXG3gx37ERUQQRSR7nHuQPo/YM35GYlTnvW6TmE83+x9xeZSj/cnmXsps7U+103jQaCPZw/FpuPFmDki0eteL92cjI93nseEfpEwWezYebYcD17rzPg7QDsZxjNfY39wORh4AM4IZZg9DhrmQGji4ziUtxsNfUD3R+mhczgwDt71d3DAFxrncvWGYSW5RY06mXO11naVAqmmrhNEdJV6EEIIIZ2KF8vwc+njAIB5Is85MwMn3AvgXp/XpSl6ItFq85uMjrf5T273SqhzPs8JmXuV0rU9w3FtT99DYz0i1Hh5qnvjzPH93L022ppclDM1gHJUiELRsM78kV4PYsi1zgzIpT+ew+YSIMViwbiaWnyk9b37+BmpFGl1dTgol6NEJMKcympskIbirAwQM4bbjSbE2+T4vk803q9JwRC1Euk+79QxaAIwIYQQAmBQQjCGJoZgRPdQ9I/1vfFiS6xK7xVAEZGjkFzjDnSiw77yKlPDtX44rDkx8hMAgIYcwskWC5Qi9xCRpsbZC8NZtYg0q5FYGQcO7snHGod77s5t9Yn+rJwIQyoi0c3mHHqbZjDiz+WVmGQrRJFYAqPcgBJx2zfkbE8UzBBCCCEANHIJvpyTjs8eGg65xDufS3Myq6pxf4kIocEpXudEYjl25y1xva+SV3qVsbHLDwaqVYn4VekMiqSOcLyW78Cy0nKPMgqLe8hrrvHvrp6oBvGl7pVNO+rnydghwl3WxaipX+H1pVoNz/zInY+CGUIIIeQynLMWYqNSgTIJg1Ya6nU+RqeATul7CMpm6A8A4GtGXXY9+ka5d/ruYSlDmdyMbUoFymxVXmWPquvAiZ3HNYoU8IxBbxNgdbiHndYHqQAAdt4BqZh37U1p5Z19OXt1k6CwOyc/y+1tmwTd3iiYIYQQQi5DlcOE/XI5qqVmiCzeqf3Vcgl2Lhrn89q6gukwnX4eYkPrshQ3Z2SPMBw9l4ej5/KwvPw0flJL8HpIMEpsFa4yoZzK9ToCzh4iZcR04PRTyMt5GUMHDfO6b0plBPb/OQOSRsn+imfvxeDHP0NEnXOH7nDzmcuu/+WgYIYQQgi5DEp5FMIcDmSVlUJc53trAYVUhKT6/SX7mN27TPeMUIPZNRjR3btH51JYmHNdzyH0wdL6ISalMsZ1foAoFj/mF+CH/ALwdhX0Gmddqh16WJkCMqWPTSMZD7Xcs2cpTJ8AjucRqpqK5IsDEaa+uV3qf6loNRMhhBByGUKjJgO/nsAjFj2e0nbzW64w/zEkB/2G0zXXu46temAodp8rx/V9Wt46oDVutGahL5eHA/LhSKo9hMT8coRe67nPUqzduRD80bE9MGbIQPyU7d7qIFreE+a8BwDOAWXcKgBwDZHdZNHjZ5nnHBwh6Drsrk7EIE33dqn/paJghhBCCLkMHM9jX+31LZYrtcejtCoeEpF724FonQK3psU2c1Xb5LAY5LAYhHJS/OpIA/yvCsf45EhEhqo8jnEcB0dNL0i5GtcxRX2kIOnCIQMNMxFCCCEdoF+0c4LumF7N7+V0OcT1+zMNTHDvRxWqcq+U2m4/jdSkeKQmxcNkcwYsIY3OxwY7dwEXmDtwUfHODMPHNI16ePi2rfa60rpumEUIIYRcRf4zczB+PVOO6/tcuWBm3ePX4vciA8YnR2LXuXKIeQ499e4VSsXaFKB8DwDA7DADAKZeEwOlVIy4EAVSY7RYOWsIbA4Br351B0Jk56BIeQwAsFtWB3ju8oDJ/SPRPUKFftGXlpenvVAwQwghhFwGqdg9yCEV+R/wiNIqcMeg9htS8qV3pBq9I53By3W9vYOmvsETsKH8A49jUjGPyf2jXO+v6xMBi92Bh+sGA3WDMUKhAwBUC2e97jcoIQSDEkK8jnc0CmYIIYSQyzA0KQQPjkqCRMwjNaZzeyhaIuWVEAuAnQeYyHfuGwCQiUVYemsKjl6oxrQhzp3Cuwt65DUUEBzoSiFE16kJIYQQEoBkYhH+fFNyZ1ejVSIqD4CBA8AgKMKaLTtjWALQKO3M1Mqj2KrxX74z0QRgQggh5A+irHoHHDxruWCAoWCGEEII+YPIF7z3hWqtKs6GaJu95YKdgIIZQggh5A+IN5e0qfwBZSguSsSIsgrg+a41S6Vr1YYQQgghHYITHG0qL+jmQn2oN87bYsHxXasvhIIZQggh5A9CJg4G6keKZC1MAG4qRifHRWtvAADXQtmORsEMIYQQ8gcRGvMg+u0oRo1NjyB1XJuuvX9kEsKCZOgbpQHPd61whoIZQggh5A+CEymxq+pPl3StSibGtKHx7Vyj9tG1Br0IIYQQQtqIghlCCCGEBDQaZiKEEEL+IIZ3C0WUVo64ECUiNfLOrk67oWCGEEII+YPopVdj53PjOrsa7Y6GmQghhBAS0CiYIYQQQkhAo2CGEEIIIQGNghlCCCGEBDQKZgghhBAS0CiYIYQQQkhAo2CGEEIIIQGNghlCCCGEBDQKZgghhBAS0CiYIYQQQkhAo2CGEEIIIQGNghlCCCGEBDQKZgghhBAS0CiYIYQQQkhAE3d2Ba40xhgAwGAwdHJNCCGEENJaDc/thud4c676YMZoNAIA4uLiOrkmhBBCCGkro9EIrVbbbBmOtSbkCWCCIODixYtQq9XgOK7d7mswGBAXF4f8/HxoNJp2uy/xRO3ccaitOwa1c8egdu4YV7KdGWMwGo2Ijo4Gzzc/K+aq75nheR6xsbFX7P4ajYb+oXQAaueOQ23dMaidOwa1c8e4Uu3cUo9MA5oATAghhJCARsEMIYQQQgIaBTOXSCaTYfHixZDJZJ1dlasatXPHobbuGNTOHYPauWN0lXa+6icAE0IIIeTqRj0zhBBCCAloFMwQQgghJKBRMEMIIYSQgEbBDCGEEEICGgUzl+if//wnEhMTIZfLMWzYMOzZs6ezqxQwsrKyMGTIEKjVakREROCWW27ByZMnPcrU1dUhMzMToaGhCAoKwu23347i4mKPMnl5eZg8eTKUSiUiIiKwcOFC2O32jvwqAWXZsmXgOA7z5893HaN2bj8FBQW45557EBoaCoVCgdTUVOzbt891njGGv/zlL4iKioJCoUBGRgZOnz7tcY+KigrMmDEDGo0GOp0Os2fPhslk6uiv0mU5HA68+OKLSEpKgkKhQPfu3bFkyRKPvXuondvu559/xpQpUxAdHQ2O47BmzRqP8+3VpkeOHMG1114LuVyOuLg4vPrqq+33JRhps9WrVzOpVMo++OADduzYMfbQQw8xnU7HiouLO7tqAWHChAls5cqVLDs7mx06dIjdeOONLD4+nplMJleZOXPmsLi4OLZ582a2b98+Nnz4cDZixAjXebvdzlJSUlhGRgY7ePAg++GHH1hYWBh77rnnOuMrdXl79uxhiYmJrH///uyJJ55wHad2bh8VFRUsISGBzZo1i+3evZudPXuWrV+/np05c8ZVZtmyZUyr1bI1a9aww4cPs5tvvpklJSWx2tpaV5mJEyeyAQMGsF27drFffvmF9ejRg02fPr0zvlKXtHTpUhYaGsrWrl3Lzp07x7766isWFBTEli9f7ipD7dx2P/zwA3vhhRfYN998wwCwb7/91uN8e7RpdXU10+v1bMaMGSw7O5t9/vnnTKFQsH/961/t8h0omLkEQ4cOZZmZma73DoeDRUdHs6ysrE6sVeAqKSlhANj27dsZY4xVVVUxiUTCvvrqK1eZEydOMABs586djDHnPz6e51lRUZGrzLvvvss0Gg2zWCwd+wW6OKPRyHr27Mk2btzIxowZ4wpmqJ3bz7PPPstGjRrl97wgCCwyMpL9/e9/dx2rqqpiMpmMff7554wxxo4fP84AsL1797rK/Pjjj4zjOFZQUHDlKh9AJk+ezB544AGPY7fddhubMWMGY4zauT00DWbaq03feecdFhwc7PF749lnn2W9e/dul3rTMFMbWa1W7N+/HxkZGa5jPM8jIyMDO3fu7MSaBa7q6moAQEhICABg//79sNlsHm3cp08fxMfHu9p4586dSE1NhV6vd5WZMGECDAYDjh071oG17/oyMzMxefJkj/YEqJ3b0//+9z8MHjwYd955JyIiIpCWlob33nvPdf7cuXMoKiryaGutVothw4Z5tLVOp8PgwYNdZTIyMsDzPHbv3t1xX6YLGzFiBDZv3oxTp04BAA4fPowdO3Zg0qRJAKidr4T2atOdO3di9OjRkEqlrjITJkzAyZMnUVlZedn1vOo3mmxvZWVlcDgcHr/cAUCv1+P333/vpFoFLkEQMH/+fIwcORIpKSkAgKKiIkilUuh0Oo+yer0eRUVFrjK+/gwazhGn1atX48CBA9i7d6/XOWrn9nP27Fm8++67eOqpp/D8889j7969ePzxxyGVSjFz5kxXW/lqy8ZtHRER4XFeLBYjJCSE2rreokWLYDAY0KdPH4hEIjgcDixduhQzZswAAGrnK6C92rSoqAhJSUle92g4FxwcfFn1pGCGdKrMzExkZ2djx44dnV2Vq05+fj6eeOIJbNy4EXK5vLOrc1UTBAGDBw/G3/72NwBAWloasrOzsWLFCsycObOTa3f1+PLLL/Hpp5/is88+Q79+/XDo0CHMnz8f0dHR1M5/cDTM1EZhYWEQiUReKz6Ki4sRGRnZSbUKTHPnzsXatWuxdetWxMbGuo5HRkbCarWiqqrKo3zjNo6MjPT5Z9BwjjiHkUpKSjBw4ECIxWKIxWJs374db731FsRiMfR6PbVzO4mKikJycrLHsb59+yIvLw+Au62a+70RGRmJkpISj/N2ux0VFRXU1vUWLlyIRYsWYdq0aUhNTcW9996LJ598EllZWQCona+E9mrTK/27hIKZNpJKpRg0aBA2b97sOiYIAjZv3oz09PROrFngYIxh7ty5+Pbbb7FlyxavrsdBgwZBIpF4tPHJkyeRl5fnauP09HQcPXrU4x/Qxo0bodFovB4qf1Tjxo3D0aNHcejQIdfP4MGDMWPGDNdrauf2MXLkSK/0AqdOnUJCQgIAICkpCZGRkR5tbTAYsHv3bo+2rqqqwv79+11ltmzZAkEQMGzYsA74Fl2f2WwGz3s+tkQiEQRBAEDtfCW0V5ump6fj559/hs1mc5XZuHEjevfufdlDTABoafalWL16NZPJZOzDDz9kx48fZw8//DDT6XQeKz6If48++ijTarVs27ZtrLCw0PVjNptdZebMmcPi4+PZli1b2L59+1h6ejpLT093nW9YMjx+/Hh26NAh9tNPP7Hw8HBaMtyCxquZGKN2bi979uxhYrGYLV26lJ0+fZp9+umnTKlUsk8++cRVZtmyZUyn07HvvvuOHTlyhE2dOtXn8ta0tDS2e/dutmPHDtazZ88/9JLhpmbOnMliYmJcS7O/+eYbFhYWxp555hlXGWrntjMajezgwYPs4MGDDAB7/fXX2cGDB9n58+cZY+3TplVVVUyv17N7772XZWdns9WrVzOlUklLszvb22+/zeLj45lUKmVDhw5lu3bt6uwqBQwAPn9WrlzpKlNbW8see+wxFhwczJRKJbv11ltZYWGhx31yc3PZpEmTmEKhYGFhYezpp59mNputg79NYGkazFA7t5/vv/+epaSkMJlMxvr06cP+/e9/e5wXBIG9+OKLTK/XM5lMxsaNG8dOnjzpUaa8vJxNnz6dBQUFMY1Gw+6//35mNBo78mt0aQaDgT3xxBMsPj6eyeVy1q1bN/bCCy94LPeldm67rVu3+vydPHPmTMZY+7Xp4cOH2ahRo5hMJmMxMTFs2bJl7fYdOMYapU4khBBCCAkwNGeGEEIIIQGNghlCCCGEBDQKZgghhBAS0CiYIYQQQkhAo2CGEEIIIQGNghlCCCGEBDQKZgghhBAS0CiYIYR0aYmJiXjzzTc7uxqEkC6MghlCCABg1qxZuOWWW1zvx44di/nz53fY53/44YfQ6XRex/fu3YuHH364w+rR1LZt28BxnNeGnISQrkPc2RUghFzdrFYrpFLpJV8fHh7ejrUhhFyNqGeGEOJl1qxZ2L59O5YvXw6O48BxHHJzcwEA2dnZmDRpEoKCgqDX63HvvfeirKzMde3YsWMxd+5czJ8/H2FhYZgwYQIA4PXXX0dqaipUKhXi4uLw2GOPwWQyAXD2ftx///2orq52fd5LL70EwHuYKS8vD1OnTkVQUBA0Gg3uuusuFBcXu86/9NJLuOaaa/Dxxx8jMTERWq0W06ZNg9Fo9Pt9z58/jylTpiA4OBgqlQr9+vXDDz/8gNzcXFx33XUAgODgYHAch1mzZgEABEFAVlYWkpKSoFAoMGDAAPz3v/913bOhR2fdunXo378/5HI5hg8fjuzs7Ev+cyGE+EbBDCHEy/Lly5Geno6HHnoIhYWFKCwsRFxcHKqqqnD99dcjLS0N+/btw08//YTi4mLcddddHtevWrUKUqkUv/76K1asWAEA4Hkeb731Fo4dO4ZVq1Zhy5YteOaZZwAAI0aMwJtvvgmNRuP6vAULFnjVSxAETJ06FRUVFdi+fTs2btyIs2fP4u677/Yol5OTgzVr1mDt2rVYu3Yttm/fjmXLlvn9vpmZmbBYLPj5559x9OhRvPLKKwgKCkJcXBy+/vprAMDJkydRWFiI5cuXAwCysrLw0UcfYcWKFTh27BiefPJJ3HPPPdi+fbvHvRcuXIjXXnsNe/fuRXh4OKZMmQKbzdbGPxFCSLPabctKQkhAmzlzJps6darrfdMdthljbMmSJWz8+PEex/Lz8xkA1y66Y8aMYWlpaS1+3ldffcVCQ0Nd71euXMm0Wq1XuYSEBPbGG28wxhjbsGEDE4lELC8vz3X+2LFjDADbs2cPY4yxxYsXM6VSyQwGg6vMwoUL2bBhw/zWJTU1lb300ks+zzXsKFxZWek6VldXx5RKJfvtt988ys6ePZtNnz7d47rVq1e7zpeXlzOFQsG++OILv3UhhLQdzZkhhLTa4cOHsXXrVgQFBXmdy8nJQa9evQAAgwYN8jq/adMmZGVl4ffff4fBYIDdbkddXR3MZjOUSmWrPv/EiROIi4tDXFyc61hycjJ0Oh1OnDiBIUOGAHAOTanValeZqKgolJSU+L3v448/jkcffRQbNmxARkYGbr/9dvTv399v+TNnzsBsNuOGG27wOG61WpGWluZxLD093fU6JCQEvXv3xokTJ1r1fQkhrUPBDCGk1UwmE6ZMmYJXXnnF61xUVJTrtUql8jiXm5uLm266CY8++iiWLl2KkJAQ7NixA7Nnz4bVam11MNNaEonE4z3HcRAEwW/5Bx98EBMmTMC6deuwYcMGZGVl4bXXXsO8efN8lm+Y67Nu3TrExMR4nJPJZJdZe0JIW1EwQwjxSSqVwuFweBwbOHAgvv76ayQmJkIsbv2vj/3790MQBLz22mvgeedUvS+//LLFz2uqb9++yM/PR35+vqt35vjx46iqqkJycnKr6+NLXFwc5syZgzlz5uC5557De++9h3nz5rlWYjWuW3JyMmQyGfLy8jBmzJhm77tr1y7Ex8cDACorK3Hq1Cn07dv3supKCPFEE4AJIT4lJiZi9+7dyM3NRVlZGQRBQGZmJioqKjB9+nTs3bsXOTk5WL9+Pe6///5mA5EePXrAZrPh7bffxtmzZ/Hxxx+7JgY3/jyTyYTNmzejrKwMZrPZ6z4ZGRlITU3FjBkzcODAAezZswf33XcfxowZg8GDB1/yd50/fz7Wr1+Pc+fO4cCBA9i6dasr4EhISADHcVi7di1KS0thMpmgVquxYMECPPnkk1i1ahVycnJw4MABvP3221i1apXHvf/6179i8+bNyM7OxqxZsxAWFuaRz4cQcvkomCGE+LRgwQKIRCIkJycjPDwceXl5iI6Oxq+//gqHw4Hx48cjNTUV8+fPh06nc/W4+DJgwAC8/vrreOWVV5CSkoJPP/0UWVlZHmVGjBiBOXPm4O6770Z4eDheffVVr/twHIfvvvsOwcHBGD16NDIyMtCtWzd88cUXl/VdHQ4HMjMz0bdvX0ycOBG9evXCO++8AwCIiYnByy+/jEWLFkGv12Pu3LkAgCVLluDFF19EVlaW67p169YhKSnJ497Lli3DE088gUGDBqGoqAjff//9ZeXdIYR44xhjrLMrQQghV5tt27bhuuuuQ2Vlpc/MxoSQ9kM9M4QQQggJaBTMEEIIISSg0TATIYQQQgIa9cwQQgghJKBRMEMIIYSQgEbBDCGEEEICGgUzhBBCCAloFMwQQgghJKBRMEMIIYSQgEbBDCGEEEICGgUzhBBCCAloFMwQQgghJKD9f6n4WCKJ0W7GAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot the loss curve\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Extract iteration and loss values for each method\n", - "it_baseline = [entry['it'] for entry in step_baseline]\n", - "loss_baseline = [entry['loss'] for entry in step_baseline]\n", - "\n", - "it_jit = [entry['it'] for entry in step_jit]\n", - "loss_jit = [entry['loss'] for entry in step_jit]\n", - "\n", - "it_tcompile = [entry['it'] for entry in step_tcompile]\n", - "loss_tcompile = [entry['loss'] for entry in step_tcompile]\n", - "\n", - "# Plot loss curves\n", - "plt.plot(it_baseline, loss_baseline, label=\"Baseline\", linestyle='-')\n", - "plt.plot(it_jit, loss_jit, label=\"JIT\", linestyle='--')\n", - "plt.plot(it_tcompile, loss_tcompile, label=\"TCompile\", linestyle='-.')\n", - "\n", - "plt.xlabel('Iteration step')\n", - "plt.ylabel('Loss')\n", - "plt.title('Loss Curve')\n", - "plt.legend()\n", - "\n", - "plt.show()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If everything is working as designed, it should be nearly impossible to see the differences between the 3 lines. So lets plot the delta against baseline instead." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import numpy as np\n", - "\n", - "# Convert lists to numpy arrays for easier manipulation\n", - "loss_baseline_np = np.array(loss_baseline)\n", - "loss_jit_np = np.array(loss_jit)\n", - "loss_tcompile_np = np.array(loss_tcompile)\n", - "\n", - "# Calculate deltas\n", - "delta_jit_baseline = (loss_jit_np - loss_baseline_np)\n", - "delta_tcompile_baseline = (loss_tcompile_np - loss_baseline_np)\n", - "\n", - "# Plot deltas\n", - "plt.plot(it_jit, delta_jit_baseline, label=\"JIT - Baseline\", linestyle='-', color='blue', alpha=0.6)\n", - "plt.plot(it_tcompile, delta_tcompile_baseline, label=\"TCompile - Baseline\", linestyle='--', color='red', alpha=0.6)\n", - "\n", - "plt.xlabel('Iteration step')\n", - "plt.ylabel('Delta Loss')\n", - "plt.title('Delta Loss Curve (compared to Baseline)')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "plt.show()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If everything is working as per designed, the differences between \"Delta Loss\" should be within margin of error, of run-by-run varience" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Plot the time charts!\n", - "\n", - "Lets start with a basic iteration step over cummulative time" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "# Extract the 'it' and 'time' values from each dictionary in each list\n", - "it_baseline = [x['it'] for x in step_baseline]\n", - "time_baseline = [x['time'] for x in step_baseline]\n", - "\n", - "it_jit = [x['it'] for x in step_jit]\n", - "time_jit = [x['time'] for x in step_jit]\n", - "\n", - "it_tcompile = [x['it'] for x in step_tcompile]\n", - "time_tcompile = [x['time'] for x in step_tcompile]\n", - "\n", - "# Plot cumulative time for each iteration\n", - "plt.plot(it_baseline, time_baseline, label='Baseline')\n", - "plt.plot(it_jit, time_jit, label='Jit')\n", - "plt.plot(it_tcompile, time_tcompile, label='TCompile')\n", - "\n", - "# Label the axes\n", - "plt.xlabel('Iteration')\n", - "plt.ylabel('Cumulative Time')\n", - "\n", - "# Add a legend\n", - "plt.legend(loc='upper left')\n", - "\n", - "# Display the plot\n", - "plt.show()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If everything is working correctly it should show that\n", - "\n", - "- baseline: lowest starting time, highest accumulative rate\n", - "- JIT: similar starting time, lower accumulative rate\n", - "- TCompile: slowest starting time, lowest accumulative rate\n", - "\n", - "This can be observed by getting the average time per iteration for the first 200 steps and the following 2 x 400 steps" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Average delta time for the first 200 iterations ('warmup'):\n", - "Baseline: 875.0 ms\n", - "Jit: 860.0 ms\n", - "TCompile: 1125.0 ms\n", - "\n", - "Average delta time after 'warmup' for 400 iterations:\n", - "Baseline: 715.0 ms\n", - "Jit: 685.0 ms\n", - "TCompile: 652.5 ms\n", - "\n", - "Average delta time for last 400 iterations:\n", - "Baseline: 717.5 ms\n", - "Jit: 687.5 ms\n", - "TCompile: 655.0 ms\n" - ] - } - ], - "source": [ - "# Compute the average time for the first `n` iterations and for the rest\n", - "def compute_average_time_delta(data, start, end):\n", - " time = [x['time'] for x in data]\n", - " if start == -1:\n", - " return (time[end-1]) / (end)\n", - " else:\n", - " return (time[end-1] - time[start]) / (end - start)\n", - "\n", - "# PS, [0] pos shows the timing for the first step, so we use -1 to start from \"0\"\n", - "first_R = 200\n", - "first_R_baseline = compute_average_time_delta(step_baseline, -1, first_R)\n", - "first_R_jit = compute_average_time_delta(step_jit, -1, first_R)\n", - "first_R_tcompile = compute_average_time_delta(step_tcompile, -1, first_R)\n", - "\n", - "next_W = 400\n", - "next_W_baseline = compute_average_time_delta(step_baseline, first_R, first_R + next_W)\n", - "next_W_jit = compute_average_time_delta(step_jit, first_R, first_R + next_W)\n", - "next_W_tcompile = compute_average_time_delta(step_tcompile, first_R, first_R + next_W)\n", - "\n", - "next_K = 400\n", - "next_K_baseline = compute_average_time_delta(step_baseline, first_R + next_W, first_R + next_W + next_K)\n", - "next_K_jit = compute_average_time_delta(step_jit, first_R + next_W, first_R + next_W + next_K)\n", - "next_K_tcompile = compute_average_time_delta(step_tcompile, first_R + next_W, first_R + next_W + next_K)\n", - "\n", - "print(f\"Average delta time for the first {first_R} iterations ('warmup'):\")\n", - "print(f\"Baseline: {first_R_baseline * 1000} ms\")\n", - "print(f\"Jit: {first_R_jit * 1000} ms\")\n", - "print(f\"TCompile: {first_R_tcompile * 1000} ms\")\n", - "print(\"\")\n", - "\n", - "print(f\"Average delta time after 'warmup' for {next_W} iterations:\")\n", - "print(f\"Baseline: {next_W_baseline * 1000} ms\")\n", - "print(f\"Jit: {next_W_jit * 1000} ms\")\n", - "print(f\"TCompile: {next_W_tcompile * 1000} ms\")\n", - "print(\"\")\n", - "\n", - "print(f\"Average delta time for last {next_K} iterations:\")\n", - "print(f\"Baseline: {next_K_baseline * 1000} ms\")\n", - "print(f\"Jit: {next_K_jit * 1000} ms\")\n", - "print(f\"TCompile: {next_K_tcompile * 1000} ms\")\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "rwkv-infctx", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.4" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 4476e3b99794a6e40ba379e9d6cb27ab1480782d Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Mon, 10 Jul 2023 04:52:52 +0000 Subject: [PATCH 53/57] tweaking notebook details --- notebook/trainer-validation/deepspeed-2-and-3.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/notebook/trainer-validation/deepspeed-2-and-3.ipynb b/notebook/trainer-validation/deepspeed-2-and-3.ipynb index 22c5ee41..5e4d8f7f 100644 --- a/notebook/trainer-validation/deepspeed-2-and-3.ipynb +++ b/notebook/trainer-validation/deepspeed-2-and-3.ipynb @@ -18,7 +18,9 @@ ">\n", "> And that you have completed the `baseline-setup.ipynb`\n", "\n", - "## 2 x A5000 (24gb, NvLink, via vast.ai)\n", + "## Benchmark results on 2 x A5000 (24gb, NvLink, via vast.ai)\n", + "\n", + "(benchmark was done on 10th July 2023. With Torch 2.0.1, Cuda 11.8.)\n", "\n", "| Deepspeed Strat | Time | VRAM Usage | RAM Usage | Validation Loss |\n", "| --------------------- | --------------------- | ---------------- | --------- | --------------- |\n", From f91baae2bd344f3f8cfe87d7b66856ea76996d0d Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Mon, 10 Jul 2023 04:54:23 +0000 Subject: [PATCH 54/57] tweak --- notebook/trainer-validation/deepspeed-2-and-3.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebook/trainer-validation/deepspeed-2-and-3.ipynb b/notebook/trainer-validation/deepspeed-2-and-3.ipynb index 5e4d8f7f..ee97e810 100644 --- a/notebook/trainer-validation/deepspeed-2-and-3.ipynb +++ b/notebook/trainer-validation/deepspeed-2-and-3.ipynb @@ -16,7 +16,7 @@ "\n", "> This project assumes you have the rwkv-infctx conda env setup, and you are executing in that environment - see the main README.md for the conda env setup steps\n", ">\n", - "> And that you have completed the `baseline-setup.ipynb`\n", + "> And that you have completed the `baseline-setup.ipynb` and the environment setup found in project `README.md`\n", "\n", "## Benchmark results on 2 x A5000 (24gb, NvLink, via vast.ai)\n", "\n", From 1894e7fc67f816e4352b07044416a500b9a9caf3 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Mon, 10 Jul 2023 06:42:02 +0000 Subject: [PATCH 55/57] Added link to HF explaination of deepspeed --- notebook/trainer-validation/deepspeed-2-and-3.ipynb | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/notebook/trainer-validation/deepspeed-2-and-3.ipynb b/notebook/trainer-validation/deepspeed-2-and-3.ipynb index ee97e810..8c421adf 100644 --- a/notebook/trainer-validation/deepspeed-2-and-3.ipynb +++ b/notebook/trainer-validation/deepspeed-2-and-3.ipynb @@ -18,6 +18,18 @@ ">\n", "> And that you have completed the `baseline-setup.ipynb` and the environment setup found in project `README.md`\n", "\n", + "## What does deepspeed 2 & 3 do (With/Without CPU offload) ??\n", + "\n", + "Instead of simply splitting the dataset being trained, and having a full copy of nearly everything in all GPU's (aka DDP / DeepSpeed 1).\n", + "\n", + "Deepspeed 2, keeps a full copy of the model weights on each GPU, but splits the training gradient descent memory usage into multiple GPUs, or offload it into CPU memory (+ CPU offload option).\n", + "\n", + "Deepspeed 3, takes it a step further, and distributes the model weights across all the GPUs, drastically lowering the vram requirement, while increasing the amount of GPU to GPU traffic drastically. Gradient descent memory is still split across multiple GPUs, with the option to offload into CPU memory (Same as deepspeed 2)\n", + "\n", + "Finally, Deepspeed 3, also introduce options to further offload such model weights / gradient descent, more into CPU memory or NVMe. However this option was not enabled or explored in the following benchmarks.\n", + "\n", + "See more here: https://huggingface.co/docs/transformers/main_classes/deepspeed\n", + "\n", "## Benchmark results on 2 x A5000 (24gb, NvLink, via vast.ai)\n", "\n", "(benchmark was done on 10th July 2023. With Torch 2.0.1, Cuda 11.8.)\n", From e6d203b2bcd041d920e147359e7eece0944bba89 Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Mon, 10 Jul 2023 19:45:38 +0000 Subject: [PATCH 56/57] optimizing main forward pass BlockStateList --- RWKV-v4neo/src/model.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/RWKV-v4neo/src/model.py b/RWKV-v4neo/src/model.py index a97d0d87..9c0d6be3 100644 --- a/RWKV-v4neo/src/model.py +++ b/RWKV-v4neo/src/model.py @@ -662,10 +662,10 @@ def forward(self, idx: torch.Tensor, last_shift_states: torch.Tensor, # zip(self.blocks, # BlockStateList(last_shift_states, last_wkv_states))): # --- + bs_list = BlockStateList(last_shift_states, last_wkv_states) for i in range(len(self.blocks)): block = self.blocks[i] - last_state = BlockStateList(last_shift_states, last_wkv_states)[i] - + last_state = bs_list[i] if self.grad_cp: x, new_state = deepspeed_checkpoint( block, x, last_state) @@ -901,7 +901,7 @@ def checkpointed_step(idx, targets, mask, prev_loss, last_shift_states, steps, ) states = BlockStateList(new_shift_states, new_wkv_states) - + # Compute the backward pass for the segment if i >= first_learning_segment: # The learning loss, should be normalized against the accumulation steps From 456cf0a7291b7f728f199a265cd21047b25b2bcd Mon Sep 17 00:00:00 2001 From: "@picocreator (Eugene Cheah)" Date: Tue, 11 Jul 2023 05:09:30 +0000 Subject: [PATCH 57/57] Updating deepspeed 2 & 3 perf table --- .../deepspeed-2-and-3.ipynb | 841 +++++++++++------- 1 file changed, 508 insertions(+), 333 deletions(-) diff --git a/notebook/trainer-validation/deepspeed-2-and-3.ipynb b/notebook/trainer-validation/deepspeed-2-and-3.ipynb index 8c421adf..ed351575 100644 --- a/notebook/trainer-validation/deepspeed-2-and-3.ipynb +++ b/notebook/trainer-validation/deepspeed-2-and-3.ipynb @@ -30,16 +30,19 @@ "\n", "See more here: https://huggingface.co/docs/transformers/main_classes/deepspeed\n", "\n", - "## Benchmark results on 2 x A5000 (24gb, NvLink, via vast.ai)\n", + "## Benchmark results\n", "\n", - "(benchmark was done on 10th July 2023. With Torch 2.0.1, Cuda 11.8.)\n", + "Benchmark was done on 11th July 2023. With Torch 2.0.1, Cuda 11.8. On two seperate machines, via vast.ai\n", "\n", - "| Deepspeed Strat | Time | VRAM Usage | RAM Usage | Validation Loss |\n", - "| --------------------- | --------------------- | ---------------- | --------- | --------------- |\n", - "| Stage 2 | 24 mins : 55 sec | ~22.3 + 23.8 GB | ~85 GB | 6.173 |\n", - "| Stage 3 | 29 mins : 12 sec | ~23.0 + 23.2 GB^ | ~85 GB | 5.665 |\n", - "| Stage 2 + CPU offload | 43 mins : 08 sec | ~9.7 + 10.3 GB | ~128 GB | 6.124 |\n", - "| Stage 3 + CPU offload | 1hr : 42mins : 38 sec | ~7.0 + 7.3 GB | ~145 GB | 5.668 |\n", + "- 2 x A5000 (AMD EPYC 7513 - per gpu specs: 24gb, pcie4x16, 34.4 TFlops, nvlinked)\n", + "- 2 x 3090 (AMD EPYC 7302 - per gpu specs: 24gb, pcie3x16, 44.1 TFlops)\n", + "\n", + "| Deepspeed Strat | Time (A5000) | Time (3090) | VRAM Usage | RAM Usage | Validation Loss |\n", + "| --------------------- | --------------------- | --------------------- | ---------------- | --------- | --------------- |\n", + "| Stage 2 | 24 mins : 55 sec | 35 mins : 04 sec | ~22.3 + 23.8 GB | ~85 GB | 6.173 |\n", + "| Stage 2 + CPU offload | 43 mins : 08 sec | 59 mins : 04 sec | ~9.7 + 10.3 GB | ~128 GB | 6.124 |\n", + "| Stage 3 | 29 mins : 12 sec | 50 mins : 04 sec | ~23.0 + 23.2 GB^ | ~85 GB | 5.665 |\n", + "| Stage 3 + CPU offload | 1hr : 42mins : 38 sec | 1hr : 29mins : 15 sec | ~7.0 + 7.3 GB | ~145 GB | 5.668 |\n", "\n", "---\n", "\n", @@ -81,7 +84,7 @@ "source": [ "GPU_DEVICES=\"auto\"\n", "ENABLE_WANDB=True\n", - "WANDB_PREFIX=\"infctx-deepspeed\"\n", + "WANDB_PREFIX=\"infctx-deepspeed-deterministic\"\n", "\n", "print(\"ENABLE_WANDB:\", ENABLE_WANDB)\n", "print(\"GPU_DEVICES:\", GPU_DEVICES)\n", @@ -117,11 +120,11 @@ "\u001b[34m\u001b[1mwandb\u001b[0m: wandb version 0.15.5 is available! To upgrade, please run:\n", "\u001b[34m\u001b[1mwandb\u001b[0m: $ pip install wandb --upgrade\n", "\u001b[34m\u001b[1mwandb\u001b[0m: Tracking run with wandb version 0.15.4\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230709_163612-9qq27v2z\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Run data is saved locally in \u001b[35m\u001b[1m./wandb/run-20230710_201455-u3419fsk\u001b[0m\n", "\u001b[34m\u001b[1mwandb\u001b[0m: Run \u001b[1m`wandb offline`\u001b[0m to turn off syncing.\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-deepspeed (deepspeed_stage_2, train-ctx=1024, data-ctx=1024)\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Syncing run \u001b[33minfctx-deepspeed-deterministic (deepspeed_stage_2, train-ctx=1024, data-ctx=1024)\u001b[0m\n", "\u001b[34m\u001b[1mwandb\u001b[0m: ⭐️ View project at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation\u001b[0m\n", - "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/9qq27v2z\u001b[0m\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: 🚀 View run at \u001b[34m\u001b[4mhttps://wandb.ai/picocreator/RWKV-InfCtx-Validation/runs/u3419fsk\u001b[0m\n", "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", "Detected CUDA files, patching ldflags\n", "Emitting ninja build file /root/.cache/torch_extensions/py311_cu118/wkv_1024_bf16/build.ninja...\n", @@ -136,14 +139,14 @@ "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "Found cached dataset parquet (/root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7)\n", - "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 596.54it/s]\n", - "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-d9ebc51d67d5ce31_*_of_00128.arrow\n", - "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-161be9e5a7a54d76_*_of_00128.arrow\n", - "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-45459c41c653f279_*_of_00128.arrow\n", - "Setting ds_accelerator to cuda (auto detect)\n", + "100%|████████████████████████████████████████████| 1/1 [00:00<00:00, 706.83it/s]\n", + "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-d9ebc51d67d5ce31_*_of_00032.arrow\n", + "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-c63aa2ba2a5c9680_*_of_00032.arrow\n", + "Loading cached processed dataset at /root/.cache/huggingface/datasets/teven___parquet/teven--enwiki_10k-de63a925546e70ab/0.0.0/14a00e99c0d15a23649d0db8944380ac81082d4b021f398733dd84f3a6c569a7/cache-193f68ea4e8054de_*_of_00032.arrow\n", "[rank: 0] Global seed set to 3941088705 \n", "initializing deepspeed distributed: GLOBAL_RANK: 0, MEMBER: 1/2\n", - "[2023-07-09 16:36:32,126] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-10 20:15:11,785] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "Setting ds_accelerator to cuda (auto detect)\n", "[RWKV.model] Running RWKV model using 'torch-jit' with torch '2.0.1+cu118'\n", "[rank: 1] Global seed set to 3941088705\n", "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", @@ -155,8 +158,8 @@ "Loading extension module wkv_1024_bf16...\n", "[rank: 1] Global seed set to 3941088705\n", "initializing deepspeed distributed: GLOBAL_RANK: 1, MEMBER: 2/2\n", - "[2023-07-09 16:36:48,378] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", - "[2023-07-09 16:36:48,384] [WARNING] [deepspeed.py:637:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", + "[2023-07-10 20:15:27,547] [WARNING] [comm.py:152:init_deepspeed_backend] NCCL backend in DeepSpeed not yet implemented\n", + "[2023-07-10 20:15:27,587] [WARNING] [deepspeed.py:637:_auto_select_batch_size] Tried to infer the batch size for internal deepspeed logging from the `train_dataloader()`. To ensure DeepSpeed logging remains correct, please manually pass the plugin with the batch size, `Trainer(strategy=DeepSpeedStrategy(logging_batch_size_per_gpu=batch_size))`.\n", "Enabling DeepSpeed BF16.\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", "LOCAL_RANK: 1 - CUDA_VISIBLE_DEVICES: [0,1]\n", @@ -168,9 +171,9 @@ "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", "ninja: no work to do.\n", "Loading extension module fused_adam...\n", - "Time to load fused_adam op: 0.0640115737915039 seconds\n", + "Time to load fused_adam op: 0.08059811592102051 seconds\n", "Loading extension module fused_adam...\n", - "Time to load fused_adam op: 0.10116028785705566 seconds\n", + "Time to load fused_adam op: 0.1025228500366211 seconds\n", "Loading `train_dataloader` to estimate number of stepping batches.\n", "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", @@ -179,19 +182,19 @@ "Allowing ninja to set a default number of workers... (overridable by setting the environment variable MAX_JOBS=N)\n", "ninja: no work to do.\n", "Loading extension module utils...\n", - "Time to load utils op: 0.06395459175109863 seconds\n", + "Time to load utils op: 0.0865182876586914 seconds\n", "Loading extension module utils...\n", - "Time to load utils op: 0.10399532318115234 seconds\n", - "Rank: 1 partition count [2, 2, 2] and sizes[(757504000, False), (24576, False), (24576, False)] \n", + "Time to load utils op: 0.10229158401489258 seconds\n", "Rank: 0 partition count [2, 2, 2] and sizes[(757504000, False), (24576, False), (24576, False)] \n", + "Rank: 1 partition count [2, 2, 2] and sizes[(757504000, False), (24576, False), (24576, False)] \n", "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", "No modifications detected for re-loaded extension module utils, skipping build step...\n", "Loading extension module utils...\n", - "Time to load utils op: 0.0004949569702148438 seconds\n", + "Time to load utils op: 0.00031065940856933594 seconds\n", "Using /root/.cache/torch_extensions/py311_cu118 as PyTorch extensions root...\n", "No modifications detected for re-loaded extension module utils, skipping build step...\n", "Loading extension module utils...\n", - "Time to load utils op: 0.0009634494781494141 seconds\n", + "Time to load utils op: 0.0005862712860107422 seconds\n", "\n", " | Name | Type | Params\n", "--------------------------------------\n", @@ -204,49 +207,49 @@ "0 Non-trainable params\n", "1.5 B Total params\n", "6,060.425 Total estimated model params size (MB)\n", - "Epoch 0: 100%|█| 2632/2632 [24:55<00:00, 1.76it/s, v_num=7v2z, train/loss=6.120\n", + "Epoch 0: 100%|█| 2654/2654 [34:58<00:00, 1.26it/s, v_num=9fsk, train/loss=9.000\n", "Validation: 0it [00:00, ?it/s]\u001b[A\n", "Validation: 0%| | 0/27 [00:00) and the tensors embedded in it cannot be detected. The ZeRO-3 hooks designed to trigger before or after backward pass of the module relies on knowing the input and output tensors and therefore may not get triggered properly.\n", - "Epoch 0: 1%| | 19/2632 [00:24<56:52, 1.31s/it, v_num=t78b, train/loss=9.620][2023-07-09 13:27:34,232] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 3%| | 69/2632 [00:59<36:41, 1.16it/s, v_num=t78b, train/loss=8.620][2023-07-09 13:28:08,658] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 3%| | 79/2632 [01:06<35:40, 1.19it/s, v_num=t78b, train/loss=8.620][2023-07-09 13:28:15,525] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 4%| | 109/2632 [01:27<33:54, 1.24it/s, v_num=t78b, train/loss=9.190][2023-07-09 13:28:37,133] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 5%| | 119/2632 [01:35<33:42, 1.24it/s, v_num=t78b, train/loss=7.910][2023-07-09 13:28:45,512] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 5%| | 129/2632 [01:44<33:43, 1.24it/s, v_num=t78b, train/loss=8.440][2023-07-09 13:28:53,742] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 6%| | 159/2632 [02:07<33:01, 1.25it/s, v_num=t78b, train/loss=8.060][2023-07-09 13:29:17,175] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 9%| | 239/2632 [03:02<30:26, 1.31it/s, v_num=t78b, train/loss=7.840][2023-07-09 13:30:11,764] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 11%| | 279/2632 [03:29<29:26, 1.33it/s, v_num=t78b, train/loss=7.810][2023-07-09 13:30:38,790] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 12%| | 319/2632 [03:56<28:35, 1.35it/s, v_num=t78b, train/loss=7.690][2023-07-09 13:31:05,882] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 12%|▏| 329/2632 [04:03<28:24, 1.35it/s, v_num=t78b, train/loss=7.660][2023-07-09 13:31:12,817] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 15%|▏| 399/2632 [04:49<27:00, 1.38it/s, v_num=t78b, train/loss=7.340][2023-07-09 13:31:58,899] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 16%|▏| 419/2632 [05:03<26:42, 1.38it/s, v_num=t78b, train/loss=7.720][2023-07-09 13:32:12,770] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 16%|▏| 429/2632 [05:10<26:34, 1.38it/s, v_num=t78b, train/loss=7.590][2023-07-09 13:32:19,846] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 17%|▏| 449/2632 [05:23<26:14, 1.39it/s, v_num=t78b, train/loss=7.780][2023-07-09 13:32:33,214] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 19%|▏| 489/2632 [05:50<25:36, 1.39it/s, v_num=t78b, train/loss=7.160][2023-07-09 13:33:00,078] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 19%|▏| 509/2632 [06:04<25:19, 1.40it/s, v_num=t78b, train/loss=7.470][2023-07-09 13:33:13,465] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 20%|▏| 529/2632 [06:17<25:00, 1.40it/s, v_num=t78b, train/loss=7.530][2023-07-09 13:33:27,055] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 22%|▏| 579/2632 [06:51<24:17, 1.41it/s, v_num=t78b, train/loss=7.410][2023-07-09 13:34:00,386] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 22%|▏| 589/2632 [06:58<24:11, 1.41it/s, v_num=t78b, train/loss=7.250][2023-07-09 13:34:07,765] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 25%|▏| 649/2632 [07:38<23:20, 1.42it/s, v_num=t78b, train/loss=7.000][2023-07-09 13:34:47,598] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 25%|▎| 659/2632 [07:45<23:13, 1.42it/s, v_num=t78b, train/loss=6.750][2023-07-09 13:34:54,904] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 25%|▎| 669/2632 [07:52<23:06, 1.42it/s, v_num=t78b, train/loss=7.000][2023-07-09 13:35:01,692] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 27%|▎| 699/2632 [08:11<22:39, 1.42it/s, v_num=t78b, train/loss=7.410][2023-07-09 13:35:20,950] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 27%|▎| 709/2632 [08:18<22:31, 1.42it/s, v_num=t78b, train/loss=6.660][2023-07-09 13:35:27,584] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 28%|▎| 739/2632 [08:38<22:07, 1.43it/s, v_num=t78b, train/loss=6.970][2023-07-09 13:35:47,631] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 30%|▎| 779/2632 [09:05<21:38, 1.43it/s, v_num=t78b, train/loss=6.910][2023-07-09 13:36:15,197] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 31%|▎| 809/2632 [09:25<21:14, 1.43it/s, v_num=t78b, train/loss=6.970][2023-07-09 13:36:34,921] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 31%|▎| 819/2632 [09:32<21:07, 1.43it/s, v_num=t78b, train/loss=6.660][2023-07-09 13:36:41,969] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 31%|▎| 829/2632 [09:39<21:00, 1.43it/s, v_num=t78b, train/loss=6.720][2023-07-09 13:36:48,950] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 32%|▎| 839/2632 [09:47<20:55, 1.43it/s, v_num=t78b, train/loss=6.880][2023-07-09 13:36:56,888] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 32%|▎| 849/2632 [09:54<20:48, 1.43it/s, v_num=t78b, train/loss=6.750][2023-07-09 13:37:03,713] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 33%|▎| 869/2632 [10:08<20:33, 1.43it/s, v_num=t78b, train/loss=6.840][2023-07-09 13:37:17,424] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 34%|▎| 899/2632 [10:28<20:10, 1.43it/s, v_num=t78b, train/loss=6.690][2023-07-09 13:37:37,304] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 35%|▎| 909/2632 [10:34<20:03, 1.43it/s, v_num=t78b, train/loss=6.720][2023-07-09 13:37:44,327] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 35%|▎| 919/2632 [10:41<19:56, 1.43it/s, v_num=t78b, train/loss=6.780][2023-07-09 13:37:51,018] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 35%|▎| 929/2632 [10:48<19:49, 1.43it/s, v_num=t78b, train/loss=7.120][2023-07-09 13:37:58,071] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 36%|▎| 949/2632 [11:02<19:35, 1.43it/s, v_num=t78b, train/loss=6.500][2023-07-09 13:38:11,832] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 36%|▎| 959/2632 [11:09<19:27, 1.43it/s, v_num=t78b, train/loss=6.280][2023-07-09 13:38:18,842] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 39%|▍| 1019/2632 [11:49<18:43, 1.44it/s, v_num=t78b, train/loss=6.310[2023-07-09 13:38:59,493] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 39%|▍| 1039/2632 [12:03<18:29, 1.44it/s, v_num=t78b, train/loss=6.340[2023-07-09 13:39:13,084] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 41%|▍| 1079/2632 [12:29<17:59, 1.44it/s, v_num=t78b, train/loss=6.440[2023-07-09 13:39:39,102] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 43%|▍| 1119/2632 [12:56<17:29, 1.44it/s, v_num=t78b, train/loss=6.470[2023-07-09 13:40:05,687] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 45%|▍| 1189/2632 [13:41<16:37, 1.45it/s, v_num=t78b, train/loss=6.500[2023-07-09 13:40:51,215] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 48%|▍| 1269/2632 [14:34<15:39, 1.45it/s, v_num=t78b, train/loss=6.500[2023-07-09 13:41:43,571] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 51%|▌| 1349/2632 [15:27<14:41, 1.46it/s, v_num=t78b, train/loss=6.780[2023-07-09 13:42:36,686] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 53%|▌| 1399/2632 [15:59<14:05, 1.46it/s, v_num=t78b, train/loss=6.380[2023-07-09 13:43:09,266] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 54%|▌| 1429/2632 [16:19<13:44, 1.46it/s, v_num=t78b, train/loss=6.910[2023-07-09 13:43:28,881] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 56%|▌| 1469/2632 [16:45<13:16, 1.46it/s, v_num=t78b, train/loss=6.340[2023-07-09 13:43:55,315] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 56%|▌| 1479/2632 [16:52<13:09, 1.46it/s, v_num=t78b, train/loss=6.030[2023-07-09 13:44:02,076] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 57%|▌| 1509/2632 [17:12<12:48, 1.46it/s, v_num=t78b, train/loss=6.000[2023-07-09 13:44:22,208] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 60%|▌| 1589/2632 [18:05<11:52, 1.46it/s, v_num=t78b, train/loss=6.000[2023-07-09 13:45:14,931] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 64%|▋| 1679/2632 [19:04<10:49, 1.47it/s, v_num=t78b, train/loss=6.000[2023-07-09 13:46:13,682] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 66%|▋| 1749/2632 [19:48<10:00, 1.47it/s, v_num=t78b, train/loss=6.120[2023-07-09 13:46:58,154] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 72%|▋| 1889/2632 [21:17<08:22, 1.48it/s, v_num=t78b, train/loss=5.910[2023-07-09 13:48:26,841] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 81%|▊| 2119/2632 [23:43<05:44, 1.49it/s, v_num=t78b, train/loss=5.780[2023-07-09 13:50:53,004] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 81%|▊| 2129/2632 [23:50<05:37, 1.49it/s, v_num=t78b, train/loss=5.500[2023-07-09 13:50:59,615] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 82%|▊| 2149/2632 [24:03<05:24, 1.49it/s, v_num=t78b, train/loss=5.840[2023-07-09 13:51:12,565] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 82%|▊| 2159/2632 [24:09<05:17, 1.49it/s, v_num=t78b, train/loss=6.220[2023-07-09 13:51:19,446] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", - "Epoch 0: 100%|█| 2632/2632 [29:12<00:00, 1.50it/s, v_num=t78b, train/loss=5.530\n", + "Epoch 0: 0%| | 0/2654 [00:00) and the tensors embedded in it cannot be detected. The ZeRO-3 hooks designed to trigger before or after backward pass of the module relies on knowing the input and output tensors and therefore may not get triggered properly.\n", + "Epoch 0: 0%| | 9/2654 [00:12<1:03:18, 1.44s/it, v_num=hk35, train/loss=10.90][2023-07-10 21:52:27,545] [WARNING] [stage3.py:1832:step] 1 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 1%| | 19/2654 [00:24<55:45, 1.27s/it, v_num=hk35, train/loss=9.440][2023-07-10 21:52:38,695] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 1%| | 29/2654 [00:35<53:16, 1.22s/it, v_num=hk35, train/loss=9.310][2023-07-10 21:52:49,953] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 1%| | 39/2654 [00:46<52:02, 1.19s/it, v_num=hk35, train/loss=8.880][2023-07-10 21:53:01,142] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 2%| | 49/2654 [00:57<51:10, 1.18s/it, v_num=hk35, train/loss=8.440][2023-07-10 21:53:12,393] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 2%| | 59/2654 [01:08<50:34, 1.17s/it, v_num=hk35, train/loss=8.310][2023-07-10 21:53:23,578] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 3%| | 69/2654 [01:20<50:05, 1.16s/it, v_num=hk35, train/loss=8.440][2023-07-10 21:53:34,875] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 3%| | 79/2654 [01:31<49:43, 1.16s/it, v_num=hk35, train/loss=7.840][2023-07-10 21:53:46,127] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 3%| | 89/2654 [01:42<49:22, 1.15s/it, v_num=hk35, train/loss=8.750][2023-07-10 21:53:57,434] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 4%| | 99/2654 [01:54<49:03, 1.15s/it, v_num=hk35, train/loss=8.310][2023-07-10 21:54:08,634] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 4%| | 109/2654 [02:05<48:44, 1.15s/it, v_num=hk35, train/loss=8.380][2023-07-10 21:54:19,913] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 4%| | 119/2654 [02:16<48:28, 1.15s/it, v_num=hk35, train/loss=8.940][2023-07-10 21:54:31,134] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 5%| | 129/2654 [02:27<48:12, 1.15s/it, v_num=hk35, train/loss=8.380][2023-07-10 21:54:42,445] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 5%| | 139/2654 [02:39<47:58, 1.14s/it, v_num=hk35, train/loss=8.190][2023-07-10 21:54:53,669] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 6%| | 149/2654 [02:50<47:44, 1.14s/it, v_num=hk35, train/loss=8.000][2023-07-10 21:55:05,026] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 6%| | 159/2654 [03:01<47:30, 1.14s/it, v_num=hk35, train/loss=8.060][2023-07-10 21:55:16,241] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 6%| | 169/2654 [03:12<47:16, 1.14s/it, v_num=hk35, train/loss=7.940][2023-07-10 21:55:27,556] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 7%| | 179/2654 [03:24<47:03, 1.14s/it, v_num=hk35, train/loss=7.970][2023-07-10 21:55:38,748] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 7%| | 189/2654 [03:35<46:48, 1.14s/it, v_num=hk35, train/loss=8.810][2023-07-10 21:55:50,034] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 7%| | 199/2654 [03:46<46:36, 1.14s/it, v_num=hk35, train/loss=7.660][2023-07-10 21:56:01,273] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 8%| | 209/2654 [03:57<46:23, 1.14s/it, v_num=hk35, train/loss=7.590][2023-07-10 21:56:12,582] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 8%| | 219/2654 [04:09<46:10, 1.14s/it, v_num=hk35, train/loss=7.910][2023-07-10 21:56:23,779] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 9%| | 229/2654 [04:20<45:57, 1.14s/it, v_num=hk35, train/loss=7.810][2023-07-10 21:56:35,039] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 9%| | 239/2654 [04:31<45:45, 1.14s/it, v_num=hk35, train/loss=7.410][2023-07-10 21:56:46,272] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 9%| | 249/2654 [04:42<45:32, 1.14s/it, v_num=hk35, train/loss=7.910][2023-07-10 21:56:57,570] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 10%| | 259/2654 [04:54<45:20, 1.14s/it, v_num=hk35, train/loss=7.720][2023-07-10 21:57:08,760] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 10%| | 269/2654 [05:05<45:07, 1.14s/it, v_num=hk35, train/loss=7.780][2023-07-10 21:57:20,041] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 11%| | 279/2654 [05:16<44:55, 1.13s/it, v_num=hk35, train/loss=7.810][2023-07-10 21:57:31,226] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 11%| | 289/2654 [05:27<44:42, 1.13s/it, v_num=hk35, train/loss=7.660][2023-07-10 21:57:42,485] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 11%| | 299/2654 [05:39<44:30, 1.13s/it, v_num=hk35, train/loss=7.590][2023-07-10 21:57:53,682] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 12%| | 309/2654 [05:50<44:19, 1.13s/it, v_num=hk35, train/loss=7.620][2023-07-10 21:58:05,024] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 12%| | 319/2654 [06:01<44:07, 1.13s/it, v_num=hk35, train/loss=7.690][2023-07-10 21:58:16,304] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 12%| | 329/2654 [06:12<43:55, 1.13s/it, v_num=hk35, train/loss=7.530][2023-07-10 21:58:27,641] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 13%|▏| 339/2654 [06:24<43:44, 1.13s/it, v_num=hk35, train/loss=8.190][2023-07-10 21:58:38,891] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 13%|▏| 349/2654 [06:35<43:31, 1.13s/it, v_num=hk35, train/loss=7.530][2023-07-10 21:58:50,088] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 14%|▏| 359/2654 [06:46<43:19, 1.13s/it, v_num=hk35, train/loss=7.690][2023-07-10 21:59:01,260] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 14%|▏| 369/2654 [06:57<43:07, 1.13s/it, v_num=hk35, train/loss=8.190][2023-07-10 21:59:12,513] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 14%|▏| 379/2654 [07:09<42:55, 1.13s/it, v_num=hk35, train/loss=7.590][2023-07-10 21:59:23,706] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 15%|▏| 389/2654 [07:20<42:43, 1.13s/it, v_num=hk35, train/loss=7.840][2023-07-10 21:59:34,977] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 15%|▏| 399/2654 [07:31<42:32, 1.13s/it, v_num=hk35, train/loss=7.120][2023-07-10 21:59:46,179] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 15%|▏| 409/2654 [07:42<42:20, 1.13s/it, v_num=hk35, train/loss=7.660][2023-07-10 21:59:57,460] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 16%|▏| 419/2654 [07:54<42:08, 1.13s/it, v_num=hk35, train/loss=7.470][2023-07-10 22:00:08,664] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 16%|▏| 429/2654 [08:05<41:56, 1.13s/it, v_num=hk35, train/loss=7.810][2023-07-10 22:00:19,933] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 17%|▏| 439/2654 [08:16<41:45, 1.13s/it, v_num=hk35, train/loss=7.560][2023-07-10 22:00:31,107] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 17%|▏| 449/2654 [08:27<41:33, 1.13s/it, v_num=hk35, train/loss=7.940][2023-07-10 22:00:42,373] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 17%|▏| 459/2654 [08:39<41:22, 1.13s/it, v_num=hk35, train/loss=7.880][2023-07-10 22:00:53,695] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 18%|▏| 469/2654 [08:50<41:11, 1.13s/it, v_num=hk35, train/loss=7.340][2023-07-10 22:01:05,085] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 18%|▏| 479/2654 [09:01<41:00, 1.13s/it, v_num=hk35, train/loss=7.310][2023-07-10 22:01:16,417] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 18%|▏| 489/2654 [09:13<40:49, 1.13s/it, v_num=hk35, train/loss=7.410][2023-07-10 22:01:27,839] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 19%|▏| 499/2654 [09:24<40:37, 1.13s/it, v_num=hk35, train/loss=7.440][2023-07-10 22:01:39,083] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 19%|▏| 509/2654 [09:35<40:26, 1.13s/it, v_num=hk35, train/loss=7.780][2023-07-10 22:01:50,429] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 20%|▏| 519/2654 [09:47<40:15, 1.13s/it, v_num=hk35, train/loss=7.190][2023-07-10 22:02:01,703] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 20%|▏| 529/2654 [09:58<40:03, 1.13s/it, v_num=hk35, train/loss=7.220][2023-07-10 22:02:13,056] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 20%|▏| 539/2654 [10:09<39:52, 1.13s/it, v_num=hk35, train/loss=7.000][2023-07-10 22:02:24,259] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 21%|▏| 549/2654 [10:20<39:41, 1.13s/it, v_num=hk35, train/loss=7.090][2023-07-10 22:02:35,649] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 21%|▏| 559/2654 [10:32<39:30, 1.13s/it, v_num=hk35, train/loss=7.470][2023-07-10 22:02:47,013] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 21%|▏| 569/2654 [10:43<39:18, 1.13s/it, v_num=hk35, train/loss=7.250][2023-07-10 22:02:58,306] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 22%|▏| 579/2654 [10:54<39:07, 1.13s/it, v_num=hk35, train/loss=7.380][2023-07-10 22:03:09,548] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 22%|▏| 589/2654 [11:06<38:55, 1.13s/it, v_num=hk35, train/loss=7.500][2023-07-10 22:03:20,909] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 23%|▏| 599/2654 [11:17<38:44, 1.13s/it, v_num=hk35, train/loss=7.250][2023-07-10 22:03:32,076] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 23%|▏| 609/2654 [11:28<38:32, 1.13s/it, v_num=hk35, train/loss=6.720][2023-07-10 22:03:43,277] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 23%|▏| 619/2654 [11:39<38:20, 1.13s/it, v_num=hk35, train/loss=7.380][2023-07-10 22:03:54,426] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 24%|▏| 629/2654 [11:51<38:09, 1.13s/it, v_num=hk35, train/loss=7.750][2023-07-10 22:04:05,750] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 24%|▏| 639/2654 [12:02<37:58, 1.13s/it, v_num=hk35, train/loss=7.190][2023-07-10 22:04:17,012] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 24%|▏| 649/2654 [12:13<37:46, 1.13s/it, v_num=hk35, train/loss=7.090][2023-07-10 22:04:28,353] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 25%|▏| 659/2654 [12:25<37:35, 1.13s/it, v_num=hk35, train/loss=7.220][2023-07-10 22:04:39,644] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 25%|▎| 669/2654 [12:36<37:24, 1.13s/it, v_num=hk35, train/loss=7.280][2023-07-10 22:04:50,981] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 26%|▎| 679/2654 [12:47<37:13, 1.13s/it, v_num=hk35, train/loss=7.060][2023-07-10 22:05:02,348] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 26%|▎| 689/2654 [12:59<37:02, 1.13s/it, v_num=hk35, train/loss=6.590][2023-07-10 22:05:13,813] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 26%|▎| 699/2654 [13:10<36:51, 1.13s/it, v_num=hk35, train/loss=7.120][2023-07-10 22:05:25,198] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 27%|▎| 709/2654 [13:21<36:39, 1.13s/it, v_num=hk35, train/loss=6.470][2023-07-10 22:05:36,538] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 27%|▎| 719/2654 [13:33<36:28, 1.13s/it, v_num=hk35, train/loss=6.910][2023-07-10 22:05:47,870] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 27%|▎| 729/2654 [13:44<36:17, 1.13s/it, v_num=hk35, train/loss=7.190][2023-07-10 22:05:59,116] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 28%|▎| 739/2654 [13:55<36:05, 1.13s/it, v_num=hk35, train/loss=7.120][2023-07-10 22:06:10,441] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 28%|▎| 749/2654 [14:07<35:55, 1.13s/it, v_num=hk35, train/loss=6.720][2023-07-10 22:06:21,993] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 29%|▎| 759/2654 [14:19<35:44, 1.13s/it, v_num=hk35, train/loss=7.030][2023-07-10 22:06:33,729] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 29%|▎| 769/2654 [14:30<35:33, 1.13s/it, v_num=hk35, train/loss=7.060][2023-07-10 22:06:44,934] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 29%|▎| 779/2654 [14:41<35:21, 1.13s/it, v_num=hk35, train/loss=6.840][2023-07-10 22:06:56,221] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 30%|▎| 789/2654 [14:52<35:10, 1.13s/it, v_num=hk35, train/loss=6.910][2023-07-10 22:07:07,444] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 30%|▎| 799/2654 [15:04<34:58, 1.13s/it, v_num=hk35, train/loss=6.880][2023-07-10 22:07:18,714] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 30%|▎| 809/2654 [15:15<34:47, 1.13s/it, v_num=hk35, train/loss=7.250][2023-07-10 22:07:29,993] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 31%|▎| 819/2654 [15:26<34:36, 1.13s/it, v_num=hk35, train/loss=6.470][2023-07-10 22:07:41,377] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 31%|▎| 829/2654 [15:38<34:24, 1.13s/it, v_num=hk35, train/loss=6.690][2023-07-10 22:07:52,597] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 32%|▎| 839/2654 [15:49<34:13, 1.13s/it, v_num=hk35, train/loss=6.940][2023-07-10 22:08:03,917] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 32%|▎| 849/2654 [16:00<34:02, 1.13s/it, v_num=hk35, train/loss=7.190][2023-07-10 22:08:15,235] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 32%|▎| 859/2654 [16:12<33:51, 1.13s/it, v_num=hk35, train/loss=6.840][2023-07-10 22:08:26,693] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 33%|▎| 869/2654 [16:23<33:39, 1.13s/it, v_num=hk35, train/loss=6.660][2023-07-10 22:08:37,992] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 33%|▎| 879/2654 [16:34<33:28, 1.13s/it, v_num=hk35, train/loss=6.590][2023-07-10 22:08:49,357] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 33%|▎| 889/2654 [16:46<33:17, 1.13s/it, v_num=hk35, train/loss=7.410][2023-07-10 22:09:00,752] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 34%|▎| 899/2654 [16:57<33:06, 1.13s/it, v_num=hk35, train/loss=7.090][2023-07-10 22:09:12,165] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 34%|▎| 909/2654 [17:08<32:55, 1.13s/it, v_num=hk35, train/loss=6.470][2023-07-10 22:09:23,515] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 35%|▎| 919/2654 [17:20<32:43, 1.13s/it, v_num=hk35, train/loss=6.590][2023-07-10 22:09:34,737] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 35%|▎| 929/2654 [17:31<32:32, 1.13s/it, v_num=hk35, train/loss=6.750][2023-07-10 22:09:45,948] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 35%|▎| 939/2654 [17:42<32:20, 1.13s/it, v_num=hk35, train/loss=7.000][2023-07-10 22:09:57,229] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 36%|▎| 949/2654 [17:53<32:09, 1.13s/it, v_num=hk35, train/loss=7.000][2023-07-10 22:10:08,527] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 36%|▎| 959/2654 [18:05<31:58, 1.13s/it, v_num=hk35, train/loss=6.410][2023-07-10 22:10:19,993] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 37%|▎| 969/2654 [18:16<31:47, 1.13s/it, v_num=hk35, train/loss=6.560][2023-07-10 22:10:31,269] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 37%|▎| 979/2654 [18:27<31:35, 1.13s/it, v_num=hk35, train/loss=6.910][2023-07-10 22:10:42,542] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 37%|▎| 989/2654 [18:39<31:23, 1.13s/it, v_num=hk35, train/loss=6.840][2023-07-10 22:10:53,646] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 38%|▍| 999/2654 [18:50<31:12, 1.13s/it, v_num=hk35, train/loss=6.690][2023-07-10 22:11:04,825] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 38%|▍| 1009/2654 [19:01<31:00, 1.13s/it, v_num=hk35, train/loss=6.780[2023-07-10 22:11:16,009] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 38%|▍| 1019/2654 [19:12<30:49, 1.13s/it, v_num=hk35, train/loss=6.720[2023-07-10 22:11:27,209] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 39%|▍| 1029/2654 [19:23<30:37, 1.13s/it, v_num=hk35, train/loss=6.340[2023-07-10 22:11:38,419] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 39%|▍| 1039/2654 [19:35<30:26, 1.13s/it, v_num=hk35, train/loss=6.750[2023-07-10 22:11:49,681] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 40%|▍| 1049/2654 [19:46<30:15, 1.13s/it, v_num=hk35, train/loss=6.120[2023-07-10 22:12:00,918] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 40%|▍| 1059/2654 [19:57<30:03, 1.13s/it, v_num=hk35, train/loss=6.750[2023-07-10 22:12:12,215] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 40%|▍| 1069/2654 [20:08<29:52, 1.13s/it, v_num=hk35, train/loss=6.220[2023-07-10 22:12:23,557] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 41%|▍| 1079/2654 [20:20<29:41, 1.13s/it, v_num=hk35, train/loss=6.440[2023-07-10 22:12:35,049] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 41%|▍| 1089/2654 [20:31<29:30, 1.13s/it, v_num=hk35, train/loss=6.440[2023-07-10 22:12:46,293] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 41%|▍| 1099/2654 [20:42<29:18, 1.13s/it, v_num=hk35, train/loss=7.000[2023-07-10 22:12:57,577] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 42%|▍| 1109/2654 [20:54<29:07, 1.13s/it, v_num=hk35, train/loss=6.410[2023-07-10 22:13:08,832] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 42%|▍| 1119/2654 [21:05<28:56, 1.13s/it, v_num=hk35, train/loss=6.590[2023-07-10 22:13:20,273] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 43%|▍| 1129/2654 [21:16<28:44, 1.13s/it, v_num=hk35, train/loss=6.060[2023-07-10 22:13:31,561] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 43%|▍| 1139/2654 [21:28<28:33, 1.13s/it, v_num=hk35, train/loss=6.440[2023-07-10 22:13:42,917] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 43%|▍| 1149/2654 [21:39<28:22, 1.13s/it, v_num=hk35, train/loss=6.500[2023-07-10 22:13:54,198] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 44%|▍| 1159/2654 [21:50<28:10, 1.13s/it, v_num=hk35, train/loss=6.690[2023-07-10 22:14:05,525] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 44%|▍| 1169/2654 [22:02<27:59, 1.13s/it, v_num=hk35, train/loss=6.470[2023-07-10 22:14:16,789] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 44%|▍| 1179/2654 [22:13<27:48, 1.13s/it, v_num=hk35, train/loss=6.060[2023-07-10 22:14:28,123] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 45%|▍| 1189/2654 [22:24<27:36, 1.13s/it, v_num=hk35, train/loss=6.660[2023-07-10 22:14:39,372] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 45%|▍| 1199/2654 [22:35<27:25, 1.13s/it, v_num=hk35, train/loss=6.470[2023-07-10 22:14:50,613] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 46%|▍| 1209/2654 [22:47<27:14, 1.13s/it, v_num=hk35, train/loss=6.000[2023-07-10 22:15:01,851] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 46%|▍| 1219/2654 [22:58<27:02, 1.13s/it, v_num=hk35, train/loss=6.410[2023-07-10 22:15:13,153] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 46%|▍| 1229/2654 [23:09<26:51, 1.13s/it, v_num=hk35, train/loss=6.220[2023-07-10 22:15:24,412] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 47%|▍| 1239/2654 [23:21<26:40, 1.13s/it, v_num=hk35, train/loss=6.250[2023-07-10 22:15:35,700] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 47%|▍| 1249/2654 [23:32<26:28, 1.13s/it, v_num=hk35, train/loss=6.560[2023-07-10 22:15:46,943] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 47%|▍| 1259/2654 [23:43<26:17, 1.13s/it, v_num=hk35, train/loss=6.660[2023-07-10 22:15:58,318] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 48%|▍| 1269/2654 [23:55<26:06, 1.13s/it, v_num=hk35, train/loss=6.660[2023-07-10 22:16:09,709] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 48%|▍| 1279/2654 [24:06<25:55, 1.13s/it, v_num=hk35, train/loss=6.810[2023-07-10 22:16:21,178] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 49%|▍| 1289/2654 [24:18<25:44, 1.13s/it, v_num=hk35, train/loss=6.660[2023-07-10 22:16:32,647] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 49%|▍| 1299/2654 [24:29<25:32, 1.13s/it, v_num=hk35, train/loss=6.250[2023-07-10 22:16:44,045] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 49%|▍| 1309/2654 [24:40<25:21, 1.13s/it, v_num=hk35, train/loss=6.060[2023-07-10 22:16:55,345] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 50%|▍| 1319/2654 [24:52<25:10, 1.13s/it, v_num=hk35, train/loss=6.440[2023-07-10 22:17:06,786] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 50%|▌| 1329/2654 [25:03<24:58, 1.13s/it, v_num=hk35, train/loss=6.560[2023-07-10 22:17:18,016] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 50%|▌| 1339/2654 [25:14<24:47, 1.13s/it, v_num=hk35, train/loss=6.120[2023-07-10 22:17:29,237] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 51%|▌| 1349/2654 [25:25<24:36, 1.13s/it, v_num=hk35, train/loss=6.280[2023-07-10 22:17:40,591] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 51%|▌| 1359/2654 [25:37<24:24, 1.13s/it, v_num=hk35, train/loss=6.340[2023-07-10 22:17:51,865] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 52%|▌| 1369/2654 [25:48<24:13, 1.13s/it, v_num=hk35, train/loss=6.190[2023-07-10 22:18:03,173] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 52%|▌| 1379/2654 [25:59<24:02, 1.13s/it, v_num=hk35, train/loss=7.060[2023-07-10 22:18:14,525] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 52%|▌| 1389/2654 [26:11<23:50, 1.13s/it, v_num=hk35, train/loss=6.590[2023-07-10 22:18:25,750] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 53%|▌| 1399/2654 [26:22<23:39, 1.13s/it, v_num=hk35, train/loss=6.380[2023-07-10 22:18:37,101] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 53%|▌| 1409/2654 [26:33<23:28, 1.13s/it, v_num=hk35, train/loss=6.500[2023-07-10 22:18:48,351] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 53%|▌| 1419/2654 [26:45<23:16, 1.13s/it, v_num=hk35, train/loss=6.220[2023-07-10 22:18:59,654] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 54%|▌| 1429/2654 [26:56<23:05, 1.13s/it, v_num=hk35, train/loss=5.840[2023-07-10 22:19:10,902] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 54%|▌| 1439/2654 [27:07<22:54, 1.13s/it, v_num=hk35, train/loss=6.120[2023-07-10 22:19:22,229] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 55%|▌| 1449/2654 [27:18<22:42, 1.13s/it, v_num=hk35, train/loss=6.660[2023-07-10 22:19:33,414] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 55%|▌| 1459/2654 [27:30<22:31, 1.13s/it, v_num=hk35, train/loss=5.880[2023-07-10 22:19:44,709] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 55%|▌| 1469/2654 [27:41<22:20, 1.13s/it, v_num=hk35, train/loss=5.910[2023-07-10 22:19:55,883] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 56%|▌| 1479/2654 [27:52<22:08, 1.13s/it, v_num=hk35, train/loss=6.810[2023-07-10 22:20:07,117] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 56%|▌| 1489/2654 [28:03<21:57, 1.13s/it, v_num=hk35, train/loss=6.280[2023-07-10 22:20:18,430] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 56%|▌| 1499/2654 [28:15<21:46, 1.13s/it, v_num=hk35, train/loss=5.810[2023-07-10 22:20:29,753] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 57%|▌| 1509/2654 [28:26<21:34, 1.13s/it, v_num=hk35, train/loss=6.590[2023-07-10 22:20:41,025] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 57%|▌| 1519/2654 [28:37<21:23, 1.13s/it, v_num=hk35, train/loss=6.000[2023-07-10 22:20:52,363] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 58%|▌| 1529/2654 [28:49<21:12, 1.13s/it, v_num=hk35, train/loss=6.060[2023-07-10 22:21:03,604] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 58%|▌| 1539/2654 [29:00<21:00, 1.13s/it, v_num=hk35, train/loss=6.380[2023-07-10 22:21:14,925] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 58%|▌| 1549/2654 [29:11<20:49, 1.13s/it, v_num=hk35, train/loss=6.220[2023-07-10 22:21:26,313] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 59%|▌| 1559/2654 [29:22<20:38, 1.13s/it, v_num=hk35, train/loss=6.500[2023-07-10 22:21:37,569] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 59%|▌| 1569/2654 [29:34<20:26, 1.13s/it, v_num=hk35, train/loss=6.410[2023-07-10 22:21:48,820] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 59%|▌| 1579/2654 [29:45<20:15, 1.13s/it, v_num=hk35, train/loss=6.160[2023-07-10 22:22:00,152] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 60%|▌| 1589/2654 [29:56<20:04, 1.13s/it, v_num=hk35, train/loss=6.440[2023-07-10 22:22:11,384] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 60%|▌| 1599/2654 [30:08<19:52, 1.13s/it, v_num=hk35, train/loss=6.310[2023-07-10 22:22:22,711] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 61%|▌| 1609/2654 [30:19<19:41, 1.13s/it, v_num=hk35, train/loss=7.440[2023-07-10 22:22:33,943] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 61%|▌| 1619/2654 [30:30<19:30, 1.13s/it, v_num=hk35, train/loss=5.840[2023-07-10 22:22:45,278] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 61%|▌| 1629/2654 [30:42<19:19, 1.13s/it, v_num=hk35, train/loss=6.030[2023-07-10 22:22:56,639] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 62%|▌| 1639/2654 [30:53<19:07, 1.13s/it, v_num=hk35, train/loss=6.280[2023-07-10 22:23:08,040] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 62%|▌| 1649/2654 [31:04<18:56, 1.13s/it, v_num=hk35, train/loss=6.090[2023-07-10 22:23:19,427] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 63%|▋| 1659/2654 [31:16<18:45, 1.13s/it, v_num=hk35, train/loss=6.030[2023-07-10 22:23:30,883] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 63%|▋| 1669/2654 [31:27<18:33, 1.13s/it, v_num=hk35, train/loss=5.810[2023-07-10 22:23:42,142] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 63%|▋| 1679/2654 [31:38<18:22, 1.13s/it, v_num=hk35, train/loss=5.840[2023-07-10 22:23:53,573] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 64%|▋| 1689/2654 [31:50<18:11, 1.13s/it, v_num=hk35, train/loss=6.280[2023-07-10 22:24:04,876] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 64%|▋| 1699/2654 [32:01<18:00, 1.13s/it, v_num=hk35, train/loss=6.250[2023-07-10 22:24:16,269] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 64%|▋| 1709/2654 [32:12<17:48, 1.13s/it, v_num=hk35, train/loss=7.380[2023-07-10 22:24:27,538] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 65%|▋| 1719/2654 [32:24<17:37, 1.13s/it, v_num=hk35, train/loss=5.620[2023-07-10 22:24:38,866] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 65%|▋| 1729/2654 [32:35<17:26, 1.13s/it, v_num=hk35, train/loss=6.280[2023-07-10 22:24:50,204] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 66%|▋| 1739/2654 [32:46<17:14, 1.13s/it, v_num=hk35, train/loss=6.120[2023-07-10 22:25:01,578] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 66%|▋| 1749/2654 [32:58<17:03, 1.13s/it, v_num=hk35, train/loss=5.910[2023-07-10 22:25:12,928] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 66%|▋| 1759/2654 [33:09<16:52, 1.13s/it, v_num=hk35, train/loss=6.250[2023-07-10 22:25:24,343] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 67%|▋| 1769/2654 [33:21<16:41, 1.13s/it, v_num=hk35, train/loss=5.720[2023-07-10 22:25:35,588] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 67%|▋| 1779/2654 [33:32<16:29, 1.13s/it, v_num=hk35, train/loss=6.090[2023-07-10 22:25:46,927] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 67%|▋| 1789/2654 [33:43<16:18, 1.13s/it, v_num=hk35, train/loss=6.220[2023-07-10 22:25:58,230] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 68%|▋| 1799/2654 [33:54<16:07, 1.13s/it, v_num=hk35, train/loss=6.660[2023-07-10 22:26:09,581] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 68%|▋| 1809/2654 [34:06<15:55, 1.13s/it, v_num=hk35, train/loss=6.220[2023-07-10 22:26:21,121] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 69%|▋| 1819/2654 [34:18<15:44, 1.13s/it, v_num=hk35, train/loss=5.410[2023-07-10 22:26:32,953] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 69%|▋| 1829/2654 [34:29<15:33, 1.13s/it, v_num=hk35, train/loss=5.970[2023-07-10 22:26:44,268] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 69%|▋| 1839/2654 [34:40<15:22, 1.13s/it, v_num=hk35, train/loss=6.410[2023-07-10 22:26:55,633] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 70%|▋| 1849/2654 [34:52<15:10, 1.13s/it, v_num=hk35, train/loss=5.970[2023-07-10 22:27:06,846] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 70%|▋| 1859/2654 [35:03<14:59, 1.13s/it, v_num=hk35, train/loss=5.840[2023-07-10 22:27:18,153] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 70%|▋| 1869/2654 [35:14<14:48, 1.13s/it, v_num=hk35, train/loss=5.380[2023-07-10 22:27:29,397] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 71%|▋| 1879/2654 [35:26<14:36, 1.13s/it, v_num=hk35, train/loss=6.030[2023-07-10 22:27:40,695] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 71%|▋| 1889/2654 [35:37<14:25, 1.13s/it, v_num=hk35, train/loss=6.160[2023-07-10 22:27:51,898] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 72%|▋| 1899/2654 [35:48<14:14, 1.13s/it, v_num=hk35, train/loss=6.190[2023-07-10 22:28:03,188] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 72%|▋| 1909/2654 [35:59<14:02, 1.13s/it, v_num=hk35, train/loss=5.250[2023-07-10 22:28:14,419] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 72%|▋| 1919/2654 [36:11<13:51, 1.13s/it, v_num=hk35, train/loss=6.030[2023-07-10 22:28:25,885] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 73%|▋| 1929/2654 [36:22<13:40, 1.13s/it, v_num=hk35, train/loss=6.190[2023-07-10 22:28:37,288] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 73%|▋| 1939/2654 [36:34<13:29, 1.13s/it, v_num=hk35, train/loss=6.440[2023-07-10 22:28:48,745] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 73%|▋| 1949/2654 [36:45<13:17, 1.13s/it, v_num=hk35, train/loss=6.090[2023-07-10 22:29:00,118] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 74%|▋| 1959/2654 [36:56<13:06, 1.13s/it, v_num=hk35, train/loss=6.160[2023-07-10 22:29:11,577] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 74%|▋| 1969/2654 [37:08<12:55, 1.13s/it, v_num=hk35, train/loss=8.750[2023-07-10 22:29:22,924] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 75%|▋| 1979/2654 [37:19<12:43, 1.13s/it, v_num=hk35, train/loss=6.190[2023-07-10 22:29:34,275] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 75%|▋| 1989/2654 [37:30<12:32, 1.13s/it, v_num=hk35, train/loss=6.090[2023-07-10 22:29:45,560] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 75%|▊| 1999/2654 [37:42<12:21, 1.13s/it, v_num=hk35, train/loss=5.620[2023-07-10 22:29:56,929] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 76%|▊| 2009/2654 [37:53<12:09, 1.13s/it, v_num=hk35, train/loss=6.280[2023-07-10 22:30:08,217] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 76%|▊| 2019/2654 [38:04<11:58, 1.13s/it, v_num=hk35, train/loss=6.160[2023-07-10 22:30:19,485] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 76%|▊| 2029/2654 [38:16<11:47, 1.13s/it, v_num=hk35, train/loss=5.720[2023-07-10 22:30:30,813] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 77%|▊| 2039/2654 [38:27<11:35, 1.13s/it, v_num=hk35, train/loss=5.690[2023-07-10 22:30:42,129] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 77%|▊| 2049/2654 [38:38<11:24, 1.13s/it, v_num=hk35, train/loss=6.160[2023-07-10 22:30:53,384] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 78%|▊| 2059/2654 [38:50<11:13, 1.13s/it, v_num=hk35, train/loss=5.690[2023-07-10 22:31:04,745] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 78%|▊| 2069/2654 [39:01<11:02, 1.13s/it, v_num=hk35, train/loss=5.840[2023-07-10 22:31:16,025] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 78%|▊| 2079/2654 [39:12<10:50, 1.13s/it, v_num=hk35, train/loss=5.560[2023-07-10 22:31:27,390] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 79%|▊| 2089/2654 [39:24<10:39, 1.13s/it, v_num=hk35, train/loss=5.720[2023-07-10 22:31:38,638] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 79%|▊| 2099/2654 [39:35<10:28, 1.13s/it, v_num=hk35, train/loss=6.250[2023-07-10 22:31:49,889] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 79%|▊| 2109/2654 [39:46<10:16, 1.13s/it, v_num=hk35, train/loss=5.910[2023-07-10 22:32:01,038] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 80%|▊| 2119/2654 [39:57<10:05, 1.13s/it, v_num=hk35, train/loss=6.160[2023-07-10 22:32:12,201] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 80%|▊| 2129/2654 [40:08<09:53, 1.13s/it, v_num=hk35, train/loss=4.340[2023-07-10 22:32:23,308] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 81%|▊| 2139/2654 [40:20<09:42, 1.13s/it, v_num=hk35, train/loss=5.880[2023-07-10 22:32:34,711] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 81%|▊| 2149/2654 [40:31<09:31, 1.13s/it, v_num=hk35, train/loss=5.410[2023-07-10 22:32:45,989] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 81%|▊| 2159/2654 [40:42<09:20, 1.13s/it, v_num=hk35, train/loss=6.060[2023-07-10 22:32:57,285] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 82%|▊| 2169/2654 [40:54<09:08, 1.13s/it, v_num=hk35, train/loss=5.970[2023-07-10 22:33:08,645] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 82%|▊| 2179/2654 [41:05<08:57, 1.13s/it, v_num=hk35, train/loss=5.810[2023-07-10 22:33:20,033] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 82%|▊| 2189/2654 [41:16<08:46, 1.13s/it, v_num=hk35, train/loss=6.120[2023-07-10 22:33:31,312] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 83%|▊| 2199/2654 [41:27<08:34, 1.13s/it, v_num=hk35, train/loss=5.720[2023-07-10 22:33:42,553] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 83%|▊| 2209/2654 [41:39<08:23, 1.13s/it, v_num=hk35, train/loss=5.910[2023-07-10 22:33:53,755] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 84%|▊| 2219/2654 [41:50<08:12, 1.13s/it, v_num=hk35, train/loss=5.380[2023-07-10 22:34:05,014] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 84%|▊| 2229/2654 [42:01<08:00, 1.13s/it, v_num=hk35, train/loss=5.500[2023-07-10 22:34:16,286] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 84%|▊| 2239/2654 [42:12<07:49, 1.13s/it, v_num=hk35, train/loss=5.440[2023-07-10 22:34:27,645] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 85%|▊| 2249/2654 [42:24<07:38, 1.13s/it, v_num=hk35, train/loss=5.720[2023-07-10 22:34:39,136] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 85%|▊| 2259/2654 [42:35<07:26, 1.13s/it, v_num=hk35, train/loss=5.310[2023-07-10 22:34:50,478] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 85%|▊| 2269/2654 [42:47<07:15, 1.13s/it, v_num=hk35, train/loss=5.250[2023-07-10 22:35:01,680] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 86%|▊| 2279/2654 [42:58<07:04, 1.13s/it, v_num=hk35, train/loss=2.890[2023-07-10 22:35:12,925] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 86%|▊| 2289/2654 [43:09<06:52, 1.13s/it, v_num=hk35, train/loss=5.250[2023-07-10 22:35:24,304] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 87%|▊| 2299/2654 [43:21<06:41, 1.13s/it, v_num=hk35, train/loss=5.380[2023-07-10 22:35:35,757] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 87%|▊| 2309/2654 [43:32<06:30, 1.13s/it, v_num=hk35, train/loss=5.940[2023-07-10 22:35:47,053] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 87%|▊| 2319/2654 [43:43<06:19, 1.13s/it, v_num=hk35, train/loss=5.280[2023-07-10 22:35:58,413] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 88%|▉| 2329/2654 [43:55<06:07, 1.13s/it, v_num=hk35, train/loss=5.500[2023-07-10 22:36:09,706] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 88%|▉| 2339/2654 [44:06<05:56, 1.13s/it, v_num=hk35, train/loss=6.000[2023-07-10 22:36:21,229] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 89%|▉| 2349/2654 [44:17<05:45, 1.13s/it, v_num=hk35, train/loss=5.560[2023-07-10 22:36:32,477] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 89%|▉| 2359/2654 [44:29<05:33, 1.13s/it, v_num=hk35, train/loss=5.880[2023-07-10 22:36:43,866] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 89%|▉| 2369/2654 [44:40<05:22, 1.13s/it, v_num=hk35, train/loss=6.120[2023-07-10 22:36:55,220] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 90%|▉| 2379/2654 [44:52<05:11, 1.13s/it, v_num=hk35, train/loss=5.120[2023-07-10 22:37:06,706] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 90%|▉| 2389/2654 [45:03<04:59, 1.13s/it, v_num=hk35, train/loss=4.750[2023-07-10 22:37:18,021] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 90%|▉| 2399/2654 [45:14<04:48, 1.13s/it, v_num=hk35, train/loss=6.030[2023-07-10 22:37:29,421] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 91%|▉| 2409/2654 [45:26<04:37, 1.13s/it, v_num=hk35, train/loss=5.810[2023-07-10 22:37:40,743] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 91%|▉| 2419/2654 [45:37<04:25, 1.13s/it, v_num=hk35, train/loss=5.810[2023-07-10 22:37:52,197] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 92%|▉| 2429/2654 [45:48<04:14, 1.13s/it, v_num=hk35, train/loss=5.530[2023-07-10 22:38:03,481] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 92%|▉| 2439/2654 [46:00<04:03, 1.13s/it, v_num=hk35, train/loss=5.840[2023-07-10 22:38:14,861] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 92%|▉| 2449/2654 [46:11<03:52, 1.13s/it, v_num=hk35, train/loss=5.940[2023-07-10 22:38:26,179] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 93%|▉| 2459/2654 [46:22<03:40, 1.13s/it, v_num=hk35, train/loss=5.690[2023-07-10 22:38:37,681] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 93%|▉| 2469/2654 [46:34<03:29, 1.13s/it, v_num=hk35, train/loss=5.470[2023-07-10 22:38:49,131] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 93%|▉| 2479/2654 [46:45<03:18, 1.13s/it, v_num=hk35, train/loss=3.700[2023-07-10 22:39:00,473] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 94%|▉| 2489/2654 [46:57<03:06, 1.13s/it, v_num=hk35, train/loss=5.690[2023-07-10 22:39:11,799] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 94%|▉| 2499/2654 [47:08<02:55, 1.13s/it, v_num=hk35, train/loss=6.470[2023-07-10 22:39:23,145] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 95%|▉| 2509/2654 [47:19<02:44, 1.13s/it, v_num=hk35, train/loss=5.440[2023-07-10 22:39:34,446] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 95%|▉| 2519/2654 [47:31<02:32, 1.13s/it, v_num=hk35, train/loss=5.590[2023-07-10 22:39:45,813] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 95%|▉| 2529/2654 [47:42<02:21, 1.13s/it, v_num=hk35, train/loss=5.940[2023-07-10 22:39:57,083] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 96%|▉| 2539/2654 [47:53<02:10, 1.13s/it, v_num=hk35, train/loss=5.380[2023-07-10 22:40:08,459] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 96%|▉| 2549/2654 [48:05<01:58, 1.13s/it, v_num=hk35, train/loss=6.000[2023-07-10 22:40:19,836] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 96%|▉| 2559/2654 [48:16<01:47, 1.13s/it, v_num=hk35, train/loss=5.340[2023-07-10 22:40:31,201] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 97%|▉| 2569/2654 [48:27<01:36, 1.13s/it, v_num=hk35, train/loss=5.280[2023-07-10 22:40:42,540] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 97%|▉| 2579/2654 [48:39<01:24, 1.13s/it, v_num=hk35, train/loss=5.970[2023-07-10 22:40:54,033] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 98%|▉| 2589/2654 [48:50<01:13, 1.13s/it, v_num=hk35, train/loss=5.470[2023-07-10 22:41:05,393] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 98%|▉| 2599/2654 [49:02<01:02, 1.13s/it, v_num=hk35, train/loss=5.250[2023-07-10 22:41:16,745] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 98%|▉| 2609/2654 [49:13<00:50, 1.13s/it, v_num=hk35, train/loss=4.160[2023-07-10 22:41:28,049] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 99%|▉| 2619/2654 [49:24<00:39, 1.13s/it, v_num=hk35, train/loss=6.220[2023-07-10 22:41:39,405] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 99%|▉| 2629/2654 [49:36<00:28, 1.13s/it, v_num=hk35, train/loss=5.780[2023-07-10 22:41:50,716] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 99%|▉| 2639/2654 [49:47<00:16, 1.13s/it, v_num=hk35, train/loss=5.720[2023-07-10 22:42:02,073] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 100%|▉| 2649/2654 [49:58<00:05, 1.13s/it, v_num=hk35, train/loss=6.090[2023-07-10 22:42:13,337] [WARNING] [stage3.py:1832:step] 2 pytorch allocator cache flushes since last step. this happens when there is high memory pressure and is detrimental to performance. if this is happening frequently consider adjusting settings to reduce memory consumption. If you are unable to make the cache flushes go away consider adding get_accelerator().empty_cache() calls in your training loop to ensure that all ranks flush their caches at the same time\n", + "Epoch 0: 100%|█| 2654/2654 [50:04<00:00, 1.13s/it, v_num=hk35, train/loss=6.060\n", "Validation: 0it [00:00, ?it/s]\u001b[A\n", "Validation: 0%| | 0/27 [00:00) and the tensors embedded in it cannot be detected. The ZeRO-3 hooks designed to trigger before or after backward pass of the module relies on knowing the input and output tensors and therefore may not get triggered properly.\n", - "Epoch 0: 100%|█| 2632/2632 [1:42:38<00:00, 2.34s/it, v_num=vv2m, train/loss=5.5\n", + "Epoch 0: 0%| | 0/2654 [00:00) and the tensors embedded in it cannot be detected. The ZeRO-3 hooks designed to trigger before or after backward pass of the module relies on knowing the input and output tensors and therefore may not get triggered properly.\n", + "Epoch 0: 100%|█| 2654/2654 [1:28:53<00:00, 2.01s/it, v_num=3yg1, train/loss=6.0\n", "Validation: 0it [00:00, ?it/s]\u001b[A\n", "Validation: 0%| | 0/27 [00:00