| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| """ |
| Common utilities for FSDP2 examples. |
| """ |
|
|
| import time |
|
|
| import torch |
| from datasets import Dataset, load_dataset |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
|
|
| from accelerate import Accelerator |
|
|
|
|
| def get_dataset(accelerator: Accelerator, tokenizer: AutoTokenizer, seq_len: int) -> Dataset: |
| """ |
| Load and prepare TinyStories dataset. |
| |
| Args: |
| accelerator (Accelerator): Accelerate accelerator instance |
| tokenizer (AutoTokenizer): Hugging Face tokenizer |
| seq_len (int): Sequence length for the dataset |
| |
| Returns: |
| Dataset: Packed dataset |
| """ |
| raw_dataset = load_dataset("roneneldan/TinyStories", split="train[:50%]") |
|
|
| def tokenize_function(examples): |
| tokenized_batch = tokenizer( |
| examples["text"], |
| padding=False, |
| truncation=True, |
| max_length=seq_len, |
| return_tensors=None, |
| ) |
| tokenized_batch["labels"] = tokenized_batch["input_ids"].copy() |
| return tokenized_batch |
|
|
| with accelerator.main_process_first(): |
| tokenized_dataset = raw_dataset.map(tokenize_function, batched=True, remove_columns=["text"]) |
|
|
| def create_packed_sequences(examples): |
| all_tokens = [] |
| for input_ids in examples["input_ids"]: |
| all_tokens.extend(input_ids) |
|
|
| num_sequences = len(all_tokens) // (seq_len + 1) |
| packed_input_ids = [] |
| packed_labels = [] |
|
|
| for i in range(num_sequences): |
| start_idx = i * (seq_len + 1) |
| end_idx = start_idx + (seq_len + 1) |
| full_sequence = all_tokens[start_idx:end_idx] |
| packed_input_ids.append(full_sequence[:-1]) |
| packed_labels.append(full_sequence[1:]) |
|
|
| return {"input_ids": packed_input_ids, "shift_labels": packed_labels} |
|
|
| with accelerator.main_process_first(): |
| packed_dataset = tokenized_dataset.map( |
| create_packed_sequences, |
| batched=True, |
| remove_columns=tokenized_dataset.column_names, |
| batch_size=1000, |
| ) |
|
|
| return packed_dataset.shuffle(seed=42) |
|
|
|
|
| def get_model_flops_per_token(model: AutoModelForCausalLM, seq_len: int) -> float: |
| """ |
| Get the number of flops per token for the model. |
| |
| Args: |
| model (AutoModelForCausalLM): Model to get the flops for |
| seq_len (int): Sequence length |
| """ |
| cfg = model.config |
| head_dim = cfg.hidden_size // cfg.num_attention_heads |
|
|
| |
| mlp_flops = 18 * cfg.hidden_size * cfg.intermediate_size |
|
|
| |
| attn_flops = 12 * head_dim * (cfg.num_attention_heads + cfg.num_key_value_heads) |
|
|
| |
| attn_dotproduct_flops = 12 * cfg.num_attention_heads * head_dim * seq_len |
|
|
| |
| return (mlp_flops + attn_flops + attn_dotproduct_flops) * cfg.num_hidden_layers |
|
|
|
|
| def create_collate_fn(): |
| """Create a collate function for batching.""" |
|
|
| def collate_fn(batch): |
| input_ids = torch.tensor([item["input_ids"] for item in batch], dtype=torch.long) |
| shift_labels = torch.tensor([item["shift_labels"] for item in batch], dtype=torch.long) |
| return {"input_ids": input_ids, "shift_labels": shift_labels, "labels": shift_labels} |
|
|
| return collate_fn |
|
|
|
|
| class PerformanceTracker: |
| """Track training performance metrics.""" |
|
|
| def __init__(self, warmup_steps: int = 10): |
| self.warmup_steps = warmup_steps |
| self.reset() |
|
|
| def reset(self): |
| """Reset all tracking variables.""" |
| self.start_time = None |
| self.num_tokens = 0 |
| self.is_in_warmup = True |
| self.step_count = 0 |
|
|
| def step(self, batch_tokens: int) -> dict: |
| """ |
| Update performance tracking with a new step. |
| |
| Args: |
| batch_tokens (int): Number of tokens in current batch |
| |
| Returns: |
| dict: Performance metrics if past warmup, empty dict otherwise |
| """ |
| self.step_count += 1 |
|
|
| if self.step_count == self.warmup_steps: |
| self.start_time = time.perf_counter() |
| self.num_tokens = 0 |
| self.is_in_warmup = False |
| return {"warmup_completed": True} |
|
|
| if not self.is_in_warmup and self.start_time is not None: |
| self.num_tokens += batch_tokens |
| total_time = time.perf_counter() - self.start_time |
| steps_from_warmup = self.step_count - self.warmup_steps |
|
|
| if total_time > 0 and steps_from_warmup > 0: |
| memory_stats = gpu_memory_usage_all() |
| return { |
| "tokens_per_second": self.num_tokens / total_time, |
| "steps_per_second": steps_from_warmup / total_time, |
| "total_tokens": self.num_tokens, |
| "total_time": total_time, |
| **memory_stats, |
| } |
|
|
| return {} |
|
|
| def get_print_message(self, metrics: dict, with_memory: bool = False) -> str: |
| print_msg = f" | Average steps/s: {metrics['steps_per_second']:.2f} | Average tokens/s: {metrics['tokens_per_second']:.2f}\n" |
| if with_memory: |
| print_msg += ( |
| f"\tMemory (GB): active={metrics['peak_memory_active']:.1f}, " |
| f"alloc={metrics['peak_memory_alloc']:.1f}, " |
| f"reserved={metrics['peak_memory_reserved']:.1f}" |
| ) |
| return print_msg |
|
|
|
|
| def setup_tokenizer(model_id: str) -> AutoTokenizer: |
| """Setup tokenizer with proper padding token.""" |
| tokenizer = AutoTokenizer.from_pretrained(model_id) |
| if tokenizer.pad_token is None: |
| tokenizer.pad_token = tokenizer.eos_token |
| return tokenizer |
|
|
|
|
| def gpu_memory_usage_all(device=0): |
| device = torch.device(f"cuda:{device}") |
| _BYTES_IN_GIB = 1024**3 |
| peak_memory_active = torch.cuda.memory_stats().get("active_bytes.all.peak", 0) / _BYTES_IN_GIB |
| peak_memory_alloc = torch.cuda.max_memory_allocated(device) / _BYTES_IN_GIB |
| peak_memory_reserved = torch.cuda.max_memory_reserved(device) / _BYTES_IN_GIB |
| memory_stats = { |
| "peak_memory_active": peak_memory_active, |
| "peak_memory_alloc": peak_memory_alloc, |
| "peak_memory_reserved": peak_memory_reserved, |
| } |
| torch.cuda.reset_peak_memory_stats(device) |
|
|
| return memory_stats |
|
|
