Add files using upload-large-folder tool

litgpt/chat/base.py

@@ -0,0 +1,272 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import sys
+import time
+from pathlib import Path
+from pprint import pprint
+from typing import Iterator, List, Literal, Optional, Tuple
+
+import lightning as L
+import torch
+from lightning.fabric.plugins import BitsandbytesPrecision
+
+from litgpt.config import Config
+from litgpt.model import GPT
+from litgpt.prompts import PromptStyle, has_prompt_style, load_prompt_style
+from litgpt.scripts.merge_lora import merge_lora
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import (
+    auto_download_checkpoint,
+    check_file_size_on_cpu_and_warn,
+    extend_checkpoint_dir,
+    get_default_supported_precision,
+    load_checkpoint,
+)
+
+
+@torch.inference_mode()
+def generate(
+    model: GPT,
+    prompt: torch.Tensor,
+    max_returned_tokens: int,
+    *,
+    temperature: float = 1.0,
+    top_k: Optional[int] = None,
+    top_p: float = 1.0,
+    stop_tokens: Tuple[List[int], ...] = (),
+) -> Iterator[torch.Tensor]:
+    """Takes a conditioning sequence (prompt) as input and continues to generate as many tokens as possible.
+
+    Arguments:
+        model: The model to use.
+        prompt: Tensor of shape (T) with indices of the prompt sequence.
+        max_returned_tokens: The maximum number of tokens to return (given plus generated).
+        temperature: Scales the predicted logits by 1 / temperature
+        top_k: If specified, only sample among the tokens with the k highest probabilities.
+        top_p: If specified, it represents the cumulative probability threshold to consider in the sampling process.
+            In top-p sampling, the next token is sampled from the highest probability tokens
+            whose cumulative probability exceeds the threshold `top_p`. When specified,
+            it must be `0 <= top_p <= 1`. Here, `top_p=0` is equivalent
+            to sampling the most probable token, while `top_p=1` samples from the whole distribution.
+            It can be used in conjunction with `top_k` and `temperature` with the following order
+            of application:
+
+            1. `top_k` sampling
+            2. `temperature` scaling
+            3. `top_p` sampling
+
+            For more details, see https://arxiv.org/abs/1904.09751
+            or https://huyenchip.com/2024/01/16/sampling.html#top_p
+        stop_tokens: If specified, stop generating any more token once one of this list is generated.
+    """
+    from litgpt.generate.base import generate_fn
+
+    return generate_fn(
+        include_prompt=False,
+        include_eos=False,
+        model=model,
+        prompt=prompt,
+        max_returned_tokens=max_returned_tokens,
+        temperature=temperature,
+        top_k=top_k,
+        top_p=top_p,
+        stop_tokens=stop_tokens,
+    )
+
+
+def process_prompt(
+    prompt, model, tokenizer, prompt_style, fabric, temperature, max_new_tokens, top_k, top_p, stop_tokens
+):
+    prompt = prompt_style.apply(prompt=prompt)
+    encoded_prompt = tokenizer.encode(prompt, device=fabric.device)
+
+    if max_new_tokens is None:
+        max_returned_tokens = model.max_seq_length
+    else:
+        first_turn = model.mask_cache is None
+        max_returned_tokens = encoded_prompt.size(0) + max_new_tokens
+        if first_turn or max_returned_tokens > model.max_seq_length:
+            model.max_seq_length = max_returned_tokens
+            model.set_kv_cache(batch_size=1, device=fabric.device)
+
+    y: Iterator[torch.Tensor] = generate(
+        model,
+        encoded_prompt,
+        max_returned_tokens,
+        temperature=temperature,
+        top_k=top_k,
+        top_p=top_p,
+        stop_tokens=stop_tokens,
+    )
+    token_generator: Iterator[str] = tokenizer.decode_stream(y, device=fabric.device)
+
+    fabric.print(">> Reply: ", end="")
+
+    t0 = time.perf_counter()
+
+    tokens_generated = 0
+    for tok in token_generator:
+        tokens_generated += 1
+        fabric.print(tok, end="", flush=True)
+
+    t = time.perf_counter() - t0
+
+    for block in model.transformer.h:
+        block.attn.kv_cache.reset_parameters()
+    fabric.print(
+        f"\nTime for inference: {t:.02f} sec total, {tokens_generated / t:.02f} tokens/sec, {tokens_generated} tokens",
+        file=sys.stderr,
+    )
+    fabric.print()
+
+
+def interact(multiline, model, tokenizer, prompt_style, fabric, temperature, max_new_tokens, top_k, top_p, stop_tokens):
+    while True:
+        try:
+            if not multiline:
+                prompt = input(">> Prompt: ")
+            else:
+                print(">> Prompt: (Type '!submit' on a new line to end input).")
+                prompt_lines = []
+                while True:
+                    line = input()
+                    if line.strip().lower() in ("!submit", "!quit", "!exit"):
+                        break
+                    prompt_lines.append(line)
+                prompt = "\n".join(prompt_lines)
+
+        except KeyboardInterrupt:
+            break
+
+        prompt = prompt.lower().strip()
+        if not prompt or prompt in ("!quit", "!exit"):
+            break
+
+        process_prompt(
+            prompt, model, tokenizer, prompt_style, fabric, temperature, max_new_tokens, top_k, top_p, stop_tokens
+        )
+
+
+@torch.inference_mode()
+def main(
+    checkpoint_dir: Path,
+    *,
+    max_new_tokens: int = 50,
+    top_k: Optional[int] = 50,
+    top_p: float = 1.0,
+    temperature: float = 0.8,
+    quantize: Optional[Literal["bnb.nf4", "bnb.nf4-dq", "bnb.fp4", "bnb.fp4-dq", "bnb.int8"]] = None,
+    precision: Optional[str] = None,
+    compile: bool = False,
+    multiline: bool = False,
+    access_token: Optional[str] = None,
+) -> None:
+    """Chat with a model.
+
+    Args:
+        checkpoint_dir: A local path to a directory containing the model weights or a valid model name.
+            You can get a list of valid model names via the `litgpt download list` command line argument.
+        max_new_tokens: The number of generation steps to take.
+        top_k: The number of top most probable tokens to consider in the sampling process.
+        top_p: If specified, it represents the cumulative probability threshold to consider in the sampling process.
+            In top-p sampling, the next token is sampled from the highest probability tokens
+            whose cumulative probability exceeds the threshold `top_p`. When specified,
+            it must be `0 <= top_p <= 1`. Here, `top_p=0` is equivalent
+            to sampling the most probable token, while `top_p=1` samples from the whole distribution.
+            It can be used in conjunction with `top_k` and `temperature` with the following order
+            of application:
+
+            1. `top_k` sampling
+            2. `temperature` scaling
+            3. `top_p` sampling
+
+            For more details, see https://arxiv.org/abs/1904.09751
+            or https://huyenchip.com/2024/01/16/sampling.html#top_p
+        temperature: A value controlling the randomness of the sampling process. Higher values result in more random
+            samples.
+        quantize: Whether to quantize the model and using which method:
+            - bnb.nf4, bnb.nf4-dq, bnb.fp4, bnb.fp4-dq: 4-bit quantization from bitsandbytes
+            - bnb.int8: 8-bit quantization from bitsandbytes
+            for more details, see https://github.com/Lightning-AI/litgpt/blob/main/tutorials/quantize.md
+        precision: Indicates the Fabric precision setting to use.
+        compile: Whether to use compilation to speed up token generation. Will increase startup time.
+        multiline: Whether to support multiline input prompts.
+        access_token: Optional API token to access models with restrictions.
+    """
+    checkpoint_dir = extend_checkpoint_dir(checkpoint_dir)
+    pprint(locals())
+
+    precision = precision or get_default_supported_precision(training=False)
+
+    plugins = None
+    if quantize is not None and quantize.startswith("bnb."):
+        if "mixed" in precision:
+            raise ValueError("Quantization and mixed precision is not supported.")
+        dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
+        plugins = BitsandbytesPrecision(quantize[4:], dtype)
+        precision = None
+
+    fabric = L.Fabric(devices=1, precision=precision, plugins=plugins)
+
+    # Merge if this is a raw LoRA checkpoint
+    checkpoint_path = checkpoint_dir / "lit_model.pth"
+    if (checkpoint_dir / "lit_model.pth.lora").is_file() and not checkpoint_path.is_file():
+        print("Merging LoRA weights with the base model. This won't take long and is a one-time-only thing.")
+        merge_lora(checkpoint_dir)
+
+    if not checkpoint_path.is_file():
+        checkpoint_dir = auto_download_checkpoint(model_name=checkpoint_dir, access_token=access_token)
+        checkpoint_path = checkpoint_dir / "lit_model.pth"
+
+    check_file_size_on_cpu_and_warn(checkpoint_path, fabric.device)
+    config = Config.from_file(checkpoint_dir / "model_config.yaml")
+
+    with fabric.init_module(empty_init=True):
+        model = GPT(config)
+        if compile:
+            print(
+                "IMPORTANT: with enabled compilation the KV-cache size is determined by model's maximum context size, which leads to "
+                "a higher memory consumption. In case of an OOM error, try to set `--compile=False`."
+            )
+            model.set_kv_cache(batch_size=1)
+    load_checkpoint(fabric, model, checkpoint_path)
+    model.eval()
+
+    if compile:
+        torch._dynamo.config.automatic_dynamic_shapes = True
+        torch._inductor.config.triton.unique_kernel_names = True
+        torch._inductor.config.coordinate_descent_tuning = True
+        global next_token
+        next_token = torch.compile(next_token, mode="reduce-overhead", dynamic=True)
+
+    model = fabric.setup_module(model)
+
+    tokenizer = Tokenizer(checkpoint_dir)
+    prompt_style = (
+        load_prompt_style(checkpoint_dir) if has_prompt_style(checkpoint_dir) else PromptStyle.from_config(config)
+    )
+    stop_tokens = prompt_style.stop_tokens(tokenizer)
+
+    if multiline:
+        exit_instruction = "To exit, enter '!quit' or '!exit' on an empty prompt and press 'Enter'."
+    else:
+        exit_instruction = "To exit, press 'Enter' on an empty prompt."
+
+    print(f"Now chatting with {config.name}.\n{exit_instruction}\n")
+    L.seed_everything(1234)
+
+    interact(
+        multiline=multiline,
+        model=model,
+        tokenizer=tokenizer,
+        prompt_style=prompt_style,
+        fabric=fabric,
+        temperature=temperature,
+        max_new_tokens=(None if compile else max_new_tokens),
+        top_k=top_k,
+        top_p=top_p,
+        stop_tokens=stop_tokens,
+    )
+
+    if fabric.device.type == "cuda":
+        fabric.print(f"\nMemory used: {torch.cuda.max_memory_allocated() / 1e9:.02f} GB", file=sys.stderr)

litgpt/data/__init__.py

@@ -0,0 +1,39 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+from litgpt.data.alpaca import Alpaca
+from litgpt.data.alpaca_2k import Alpaca2k
+from litgpt.data.alpaca_gpt4 import AlpacaGPT4
+from litgpt.data.base import DataModule, SFTDataset, get_sft_collate_fn
+from litgpt.data.deita import Deita
+from litgpt.data.flan import FLAN
+from litgpt.data.json_data import JSON
+from litgpt.data.lima import LIMA
+from litgpt.data.lit_data import LitData
+from litgpt.data.longform import LongForm
+from litgpt.data.microllama import MicroLlama
+from litgpt.data.openwebtext import OpenWebText
+from litgpt.data.text_files import TextFiles
+from litgpt.data.tinyllama import TinyLlama
+from litgpt.data.tinystories import TinyStories
+from litgpt.data.arxiv import Arxiv
+
+__all__ = [
+    "Alpaca",
+    "Alpaca2k",
+    "AlpacaGPT4",
+    "Arxiv",
+    "Deita",
+    "FLAN",
+    "JSON",
+    "LIMA",
+    "LitData",
+    "DataModule",
+    "LongForm",
+    "OpenWebText",
+    "SFTDataset",
+    "TextFiles",
+    "TinyLlama",
+    "TinyStories",
+    "MicroLlama",
+    "get_sft_collate_fn",
+]

litgpt/data/alpaca.py

@@ -0,0 +1,141 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+"""Implementation derived from https://github.com/tloen/alpaca-lora"""
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Union
+
+import torch
+from lightning_utilities.core.imports import RequirementCache
+from torch.utils.data import DataLoader, random_split
+
+from litgpt.data.base import DataModule, SFTDataset, get_sft_collate_fn
+from litgpt.prompts import PromptStyle
+from litgpt.tokenizer import Tokenizer
+
+_URL = "https://raw.githubusercontent.com/tloen/alpaca-lora/main/alpaca_data_cleaned_archive.json"
+
+
+@dataclass
+class Alpaca(DataModule):
+    """Alpaca data module for supervised finetuning."""
+
+    mask_prompt: bool = False
+    """Whether to mask the prompt section from the label (with ``ignore_index``)."""
+    val_split_fraction: float = 0.03865  # to get exactly 2000 validation samples,
+    """The fraction of the dataset to use for the validation dataset. The rest is used for training."""
+    prompt_style: Union[str, PromptStyle] = "alpaca"
+    """The style to apply to instruction prompts. See `litgpt.prompts` for a list of available styles."""
+    ignore_index: int = -100
+    """The index to use for elements to be ignored in the label."""
+    seed: int = 42
+    """The random seed for creating the train/val splits and shuffling the dataset."""
+    num_workers: int = 4
+    """How many DataLoader processes to use for loading."""
+    download_dir: Path = Path("./data/alpaca")
+    """The directory in which the downloaded dataset gets saved."""
+    file_url: str = field(repr=False, default=_URL)
+    """The URL from where to download the dataset."""
+    file_name: str = field(repr=False, default="alpaca_data_cleaned_archive.json")
+    """The name of the dataset file to download."""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, init=False, repr=False)
+    batch_size: int = field(default=1, init=False, repr=False)
+    max_seq_length: int = field(default=-1, init=False, repr=False)
+    train_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+    test_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        if isinstance(self.prompt_style, str):
+            self.prompt_style = PromptStyle.from_name(self.prompt_style)
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.max_seq_length = -1 if max_seq_length is None else max_seq_length
+
+    def prepare_data(self) -> None:
+        self.download_dir.mkdir(parents=True, exist_ok=True)
+        download_if_missing(self.download_dir / self.file_name, self.file_url)
+
+    def setup(self, stage: str = "") -> None:
+        with open(self.download_dir / self.file_name, encoding="utf-8") as file:
+            data = json.load(file)
+
+        # Partition the dataset into train and test
+        train_data, test_data = random_split(
+            data,
+            [1.0 - self.val_split_fraction, self.val_split_fraction],
+            generator=torch.Generator().manual_seed(self.seed),
+        )
+        train_data, test_data = list(train_data), list(test_data)
+
+        self.train_dataset = SFTDataset(
+            data=train_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+        self.test_dataset = SFTDataset(
+            data=test_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+
+    def train_dataloader(self) -> DataLoader:
+        return DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            generator=torch.Generator().manual_seed(self.seed),
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+    def val_dataloader(self) -> DataLoader:
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+
+def download_if_missing(file_path: Path, file_url: str, mode: str = "w", stream: bool = False) -> None:
+    """Downloads the raw json data file and saves it in the given destination."""
+    if file_path.exists() and file_path.stat().st_size > 0:
+        return
+    requests_available = RequirementCache("requests")
+    if not requests_available:
+        raise ModuleNotFoundError(str(requests_available))
+    import requests
+
+    response = requests.get(file_url, stream=stream)
+    with open(file_path, mode, encoding=None if mode == "wb" else "utf-8") as f:
+        if stream:
+            # credit: https://github.com/karpathy/llama2.c/blob/b3c4b6/tinystories.py#L25-L38
+            from tqdm import tqdm
+
+            pbar = tqdm(
+                desc=str(file_path),
+                total=int(response.headers.get("content-length", 0)),
+                unit="iB",
+                unit_scale=True,
+                unit_divisor=1024,
+            )
+            for data in response.iter_content(chunk_size=1024):
+                size = f.write(data)
+                pbar.update(size)
+            pbar.close()
+        else:
+            f.write(response.text)

litgpt/data/alpaca_2k.py

@@ -0,0 +1,53 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from litgpt.data.alpaca import Alpaca
+from litgpt.data.base import SFTDataset
+
+
+@dataclass
+class Alpaca2k(Alpaca):
+    """Alpaca2k data module for supervised finetuning."""
+
+    val_split_fraction: float = 0.05  # to get exactly 100 validation samples,
+    """The fraction of the dataset to use for the validation dataset. The rest is used for training."""
+    download_dir: Path = Path("./data/alpaca2k")
+    """The directory in which the downloaded datasetgets saved."""
+    repo_id: str = field(repr=False, default="mhenrichsen/alpaca_2k_test")
+    """The URL from where to download the dataset."""
+    file_name: str = field(repr=False, default="alpaca2k_data_cleaned_archive.json")
+    """The name of the dataset file to download."""
+
+    def prepare_data(self) -> None:
+        from datasets import load_dataset
+
+        load_dataset(self.repo_id, cache_dir=self.download_dir)
+
+    def setup(self, stage: str = "") -> None:
+        from datasets import load_dataset
+
+        dataset = load_dataset(self.repo_id, cache_dir=self.download_dir)
+
+        train_validation_split = dataset["train"].train_test_split(test_size=self.val_split_fraction, seed=self.seed)
+        train_data = train_validation_split["train"]
+        test_data = train_validation_split["test"]
+
+        self.train_dataset = SFTDataset(
+            data=train_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+        self.test_dataset = SFTDataset(
+            data=test_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )

litgpt/data/alpaca_gpt4.py

@@ -0,0 +1,23 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from litgpt.data.alpaca import Alpaca
+
+_URL = "https://raw.githubusercontent.com/Instruction-Tuning-with-GPT-4/GPT-4-LLM/main/data/alpaca_gpt4_data.json"
+
+
+@dataclass
+class AlpacaGPT4(Alpaca):
+    """AlpacaGPT4 data module for supervised finetuning."""
+
+    val_split_fraction: float = 0.03847  # to get exactly 2000 test samples,
+    """The fraction of the dataset to use for the validation dataset. The rest is used for training."""
+    download_dir: Path = Path("./data/alpacagpt4")
+    """The directory in which the downloaded datasetgets saved."""
+    file_url: str = field(repr=False, default=_URL)
+    """The URL from where to download the dataset."""
+    file_name: str = field(repr=False, default="alpacagpt4_data_cleaned_archive.json")
+    """The name of the dataset file to download."""

litgpt/data/arxiv.py

@@ -0,0 +1,81 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Union
+
+from torch.utils.data import DataLoader
+
+from litgpt.data import DataModule
+from litgpt.tokenizer import Tokenizer
+
+
+@dataclass
+class Arxiv(DataModule):
+    """The TinyLlama data module is composed of a mix of SlimPajama and Starcoder data.
+
+    Provides training and validation streaming dataloaders that return batches of tokens.
+    """
+
+    data_path: Union[str, Path] = Path("litgpt/data/arxiv/")
+    seed: int = 42
+    """The random seed for shuffling the dataset."""
+    num_workers: int = 0
+    """How many DataLoader processes to use for loading."""
+    use_starcoder: bool = True
+    """Toggle for using Starcoder data."""
+    ppl: bool = False
+
+    batch_size: int = field(init=False, repr=False, default=1)
+    seq_length: int = field(init=False, repr=False, default=1024)
+
+    def __post_init__(self):
+        super().__init__()
+        # Could be a remote path (s3://) or a local path
+        self.arxiv_train = str(self.data_path).rstrip("/") + "/train"
+        self.arxiv_val = str(self.data_path).rstrip("/") + "/val"
+        self.required_paths = [self.arxiv_train, self.arxiv_val]
+
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.batch_size = batch_size
+        self.seq_length = max_seq_length + 1  # Increase by one because we need the next token as well
+
+
+    def train_dataloader(self) -> DataLoader:
+        from litdata.streaming import CombinedStreamingDataset, StreamingDataLoader, StreamingDataset, TokensLoader
+
+        arxiv_train_data = StreamingDataset(
+            input_dir=self.arxiv_train,
+            item_loader=TokensLoader(block_size=self.seq_length),
+            shuffle=True,
+            drop_last=True,
+        )
+        train_data = arxiv_train_data
+
+        train_dataloader = StreamingDataLoader(
+            train_data, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return train_dataloader
+
+    def val_dataloader(self) -> DataLoader:
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        if self.ppl:
+            val_dataset = StreamingDataset(
+                input_dir=self.arxiv_val,
+                item_loader=TokensLoader(block_size=self.seq_length),
+                shuffle=True
+            )
+        else:
+            val_dataset = StreamingDataset(
+                input_dir=self.arxiv_val,
+                item_loader=TokensLoader(block_size=self.seq_length),
+                shuffle=False
+            )
+
+        val_dataloader = StreamingDataLoader(
+            val_dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return val_dataloader

litgpt/data/base.py

@@ -0,0 +1,143 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+from abc import abstractmethod
+from functools import partial
+from typing import Any, Callable, Dict, List, Optional, Union
+
+import torch
+from lightning import LightningDataModule
+from torch import Tensor
+from torch.utils.data import Dataset
+
+from litgpt.prompts import PromptStyle
+from litgpt.tokenizer import Tokenizer
+
+
+class DataModule(LightningDataModule):
+    """Base class for all data modules in LitGPT."""
+
+    @abstractmethod
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        """All settings that can't be determined at the time of instantiation need to be passed through here
+        before any dataloaders can be accessed.
+        """
+
+    def setup(self, stage: str = "") -> None:
+        # Stub is to redefine the default signature, because the concept of 'stage' does not exist in LitGPT
+        pass
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+
+class SFTDataset(Dataset):
+    """An in-memory dataset for supervised finetuning with `input_ids` and `labels`.
+
+    Args:
+        data: A list of samples (dicts). The target/label must be stored under the key 'output' and the instruction
+            or other data can be stored under any key as long as it is compatible with the given prompt template.
+        tokenizer: The tokenizer to use. Should match the one that was used to pretrain the model.
+        prompt_style: The style to apply to prompts. See `litgpt.prompts` for a list of available styles.
+        max_seq_length: Truncate sequences that are longer than this value. By default, no truncation is applied.
+        mask_prompt: Whether to mask the prompt section from the label (with ``ignore_index``).
+        ignore_index: The index to use for elements to be ignored in the label.
+        transform: An optional transform to apply to the sample before it gets tokenized. Use this to rename the
+            keys in the dataset to the expected 'instruction' and 'output' keys.
+
+    Returns a dict with two keys:
+        input_ids: The encoded prompt + response
+        labels: Same as input_ids, unless ``mask_prompt=True`` in which case the 'prompt' part is replaced with
+            the ``ignore_index``.
+    """
+
+    def __init__(
+        self,
+        data: List[Dict[str, str]],
+        tokenizer: Tokenizer,
+        prompt_style: Union[str, PromptStyle],
+        max_seq_length: int = -1,
+        mask_prompt: bool = True,
+        ignore_index: int = -100,
+        transform: Optional[Callable[[Any], Any]] = None,
+    ) -> None:
+        self.data = data
+        self.tokenizer = tokenizer
+        self.prompt_style = (
+            prompt_style if isinstance(prompt_style, PromptStyle) else PromptStyle.from_name(prompt_style)
+        )
+        self.max_seq_length = max_seq_length
+        self.mask_prompt = mask_prompt
+        self.ignore_index = ignore_index
+        self.transform = transform
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __getitem__(self, idx: int) -> Dict[str, Union[Tensor, Dict[str, int]]]:
+        example = self.data[idx]
+        if self.transform is not None:
+            example = self.transform(example)
+        prompt = self.prompt_style.apply(prompt=example["instruction"], **example)
+        encoded_prompt = self.tokenizer.encode(prompt, max_length=self.max_seq_length)
+        encoded_response = self.tokenizer.encode(example["output"], bos=False, eos=True, max_length=self.max_seq_length)
+        encoded_prompt_and_response = torch.cat((encoded_prompt, encoded_response)).type(torch.int64)
+        if self.max_seq_length > 0:  # do not slice off last token when self.max_seq_length = -1
+            encoded_prompt_and_response = encoded_prompt_and_response[: self.max_seq_length]
+
+        # The labels are the full prompt with response, but with the prompt masked out
+        labels = encoded_prompt_and_response.clone()
+        if self.mask_prompt:
+            labels[: len(encoded_prompt)] = self.ignore_index
+
+        raw_token_count = len(self.tokenizer.encode(example["instruction"], max_length=self.max_seq_length)) + len(
+            encoded_response
+        )
+
+        return {
+            "input_ids": encoded_prompt_and_response,
+            "labels": labels,
+            "token_counts": {
+                "raw": raw_token_count,
+                "raw_plus_prompt_template": len(encoded_prompt_and_response),
+            },
+        }
+
+
+def get_sft_collate_fn(max_seq_length: int = -1, pad_id: int = 0, ignore_index: int = -100):
+    """Returns the collate function for supervised finetuning (needed in the DataLoader).
+
+    The collate function gets a list of dicts with keys `input_ids` and `labels`.
+    It returns a dict with batched `input_ids` and `labels`. Also pads short sequences to the longest element in
+    the batch. Optionally truncates all sequences to the specified maximum length.
+    """
+    return partial(_sft_collate_fn, max_seq_length=max_seq_length, pad_id=pad_id, ignore_index=ignore_index)
+
+
+def _sft_collate_fn(
+    samples: List[Dict[str, Tensor]], max_seq_length: int = -1, pad_id: int = 0, ignore_index: int = -100
+) -> Dict[str, Tensor]:
+    batched = {}
+    for key in ("input_ids", "labels"):
+        pad_value = pad_id if key == "input_ids" else ignore_index
+
+        # Pad right based on the longest sequence
+        batched[key] = torch.nn.utils.rnn.pad_sequence(
+            [sample[key] for sample in samples], batch_first=True, padding_value=pad_value
+        )
+
+        # Truncate if needed
+        if max_seq_length > 0:
+            batched[key] = batched[key][:, :max_seq_length]
+
+    batched["token_counts"] = {}
+    batched["token_counts"]["raw"] = torch.tensor(  # Token count without padding and without prompt template
+        [sample["token_counts"]["raw"] for sample in samples], dtype=torch.int64
+    ).unsqueeze(1)
+    batched["token_counts"]["raw_plus_prompt_template"] = (
+        torch.tensor(  # Token count without padding but with prompt template
+            [sample["token_counts"]["raw_plus_prompt_template"] for sample in samples], dtype=torch.int64
+        ).unsqueeze(1)
+    )
+
+    return batched

litgpt/data/count.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+import os
+import json
+
+# 数据根目录
+base_dir = '/mnt/data/litgpt/litgpt/data/arxiv'
+
+# 生成 2407-2412 和 2501-2506 的文件夹列表
+months = [f'24{m:02d}' for m in range(7, 13)] + [f'25{m:02d}' for m in range(1, 7)]
+
+overall_total = 0
+print(f"{'Month':<6}  {'Train':>12}  {'Val':>12}  {'Total':>12}")
+print("-" * 46)
+
+for month in months:
+    month_dir = os.path.join(base_dir, month)
+    if not os.path.isdir(month_dir):
+        continue
+
+    train_dim = 0
+    val_dim   = 0
+
+    # 读取 train/index.json
+    train_idx = os.path.join(month_dir, 'train', 'index.json')
+    if os.path.isfile(train_idx):
+        with open(train_idx, 'r') as f:
+            data = json.load(f)
+        train_dim = sum(chunk.get('dim', 0) for chunk in data.get('chunks', []))
+
+    # 读取 val/index.json
+    val_idx = os.path.join(month_dir, 'val', 'index.json')
+    if os.path.isfile(val_idx):
+        with open(val_idx, 'r') as f:
+            data = json.load(f)
+        val_dim = sum(chunk.get('dim', 0) for chunk in data.get('chunks', []))
+
+    total_dim = train_dim + val_dim
+    overall_total += total_dim
+
+    print(f"{month:<6}  {train_dim:12,}  {val_dim:12,}  {total_dim:12,}")
+
+print("-" * 46)
+print(f"{'Overall':<6}  {overall_total:12,}")

litgpt/data/deita.py

@@ -0,0 +1,115 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+"""Implementation derived from https://github.com/tloen/alpaca-lora"""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional, Union
+
+import torch
+from torch.utils.data import DataLoader
+
+from litgpt.data import DataModule, SFTDataset, get_sft_collate_fn
+from litgpt.prompts import PromptStyle
+from litgpt.tokenizer import Tokenizer
+
+
+@dataclass
+class Deita(DataModule):
+    """Deita data module for supervised finetuning."""
+
+    mask_prompt: bool = False
+    """Whether to mask the prompt section from the label (with ``ignore_index``)."""
+    prompt_style: Union[str, PromptStyle] = "alpaca"
+    """The style to apply to instruction prompts. See `litgpt.prompts` for a list of available styles."""
+    ignore_index: int = -100
+    """The index to use for elements to be ignored in the label."""
+    seed: int = 42
+    """The random seed for shuffling the dataset."""
+    num_workers: int = 4
+    """How many DataLoader processes to use for loading."""
+    include_multiturn_conversations: bool = False
+    """Whether to include multi-turn conversations in the dataset."""
+    download_dir: Path = Path("./data/deita")
+    """The directory in which the downloaded dataset gets saved."""
+    repo_id: str = "HuggingFaceH4/deita-10k-v0-sft"
+    """The repo from where the data is downloaded"""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, init=False, repr=False)
+    batch_size: int = field(default=1, init=False, repr=False)
+    max_seq_length: int = field(default=-1, init=False, repr=False)
+    train_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+    test_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        if isinstance(self.prompt_style, str):
+            self.prompt_style = PromptStyle.from_name(self.prompt_style)
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.max_seq_length = -1 if max_seq_length is None else max_seq_length
+
+    def prepare_data(self) -> None:
+        from datasets import load_dataset
+
+        load_dataset(self.repo_id, split=["train_sft", "test_sft"], cache_dir=self.download_dir)
+
+    def setup(self, stage: str = "") -> None:
+        from datasets import load_dataset
+
+        dataset = load_dataset(self.repo_id, split=["train_sft", "test_sft"])
+        train_data = format_dataset(dataset[0], self.include_multiturn_conversations)
+        test_data = format_dataset(dataset[1], self.include_multiturn_conversations)
+
+        self.train_dataset = SFTDataset(
+            data=train_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+        self.test_dataset = SFTDataset(
+            data=test_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+
+    def train_dataloader(self) -> DataLoader:
+        return DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            generator=torch.Generator().manual_seed(self.seed),
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+    def val_dataloader(self) -> DataLoader:
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+
+def format_dataset(dataset: List[dict], include_multi_turn_conversations: bool) -> List[dict]:
+    formatted = []
+
+    for entry in dataset:
+        convo = entry["messages"]
+        if include_multi_turn_conversations:
+            for i in range(0, len(convo) - 1, 2):
+                formatted.append({"instruction": convo[i]["content"], "input": "", "output": convo[i + 1]["content"]})
+        else:
+            formatted.append({"instruction": convo[0]["content"], "input": "", "output": convo[1]["content"]})
+
+    return formatted

litgpt/data/flan.py

@@ -0,0 +1,190 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Union
+
+import torch
+from torch.utils.data import DataLoader
+
+from litgpt.data import DataModule, SFTDataset, get_sft_collate_fn
+from litgpt.data.alpaca import download_if_missing
+from litgpt.prompts import PromptStyle
+from litgpt.tokenizer import Tokenizer
+
+_URL = "https://huggingface.co/datasets/Muennighoff/flan/resolve/main"
+
+
+# TODO: Including all subsets, FLAN is too large to be loaded in memory. Switch the implementation to cache
+#   on disk or use Lightning Data
+@dataclass
+class FLAN(DataModule):
+    """FLAN data module for supervised finetuning."""
+
+    mask_prompt: bool = False
+    """Whether to mask the prompt section from the label (with ``ignore_index``)."""
+    prompt_style: Union[str, PromptStyle] = "flan"
+    """The style to apply to instruction prompts. See `litgpt.prompts` for a list of available styles."""
+    ignore_index: int = -100
+    """The index to use for elements to be ignored in the label."""
+    seed: int = 42
+    """The random seed for shuffling the dataset."""
+    num_workers: int = 4
+    """How many DataLoader processes to use for loading."""
+    download_dir: Path = Path("./data/flan")
+    """The directory in which the downloaded dataset gets saved."""
+    url: str = _URL
+    """The URL from where to download the dataset."""
+    subsets: Optional[str] = None
+    """A comma separated list of subsets to use. If None, all subsets are used."""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, init=False, repr=False)
+    batch_size: int = field(default=1, init=False, repr=False)
+    max_seq_length: int = field(default=-1, init=False, repr=False)
+    train_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+    test_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+
+    def __post_init__(self):
+        super().__init__()
+        if isinstance(self.prompt_style, str):
+            self.prompt_style = PromptStyle.from_name(self.prompt_style)
+
+        supported_subsets = _supported_subsets()
+        if self.subsets is not None:
+            self.subsets = self.subsets.split(",")
+            for subset in self.subsets:
+                if subset not in supported_subsets:
+                    raise ValueError(f"{subset} not in {supported_subsets}")
+        else:
+            self.subsets = list(supported_subsets)
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.max_seq_length = -1 if max_seq_length is None else max_seq_length
+
+    def prepare_data(self) -> None:
+        self.download_dir.mkdir(parents=True, exist_ok=True)
+        for subset in self.subsets:
+            for split in ("train", "test"):
+                data_file_path = self.download_dir / f"{subset}_{split}.jsonl"
+                data_file_url = f"{self.url}/{split}/{subset}_{split}.jsonl"
+                download_if_missing(data_file_path, data_file_url)
+
+    def train_dataloader(self):
+        return self._dataloader("train")
+
+    def val_dataloader(self):
+        return self._dataloader("test")
+
+    def _dataloader(self, split: str) -> DataLoader:
+        data = []
+        for subset in self.subsets:
+            data_file_path = self.download_dir / f"{subset}_{split}.jsonl"
+            data.extend(load_jsonl(data_file_path))
+
+        dataset = SFTDataset(
+            data=data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+            transform=_transform,
+        )
+        return DataLoader(
+            dataset=dataset,
+            batch_size=self.batch_size,
+            shuffle=(split == "train"),
+            generator=torch.Generator().manual_seed(self.seed),
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+
+def load_jsonl(filename: Path) -> List[Dict[str, str]]:
+    data = []
+    with open(filename, encoding="utf-8") as f:
+        for line in f:
+            data.append(json.loads(line))
+    return data
+
+
+def _transform(item: dict) -> dict:
+    item["instruction"] = item.pop("inputs")
+    item["output"] = item.pop("targets")
+    return item
+
+
+def _supported_subsets() -> Set[str]:
+    return {
+        "aeslc_10templates",
+        "ag_news_subset_10templates",
+        "anli_r1_10templates",
+        "anli_r2_10templates",
+        "anli_r3_10templates",
+        "arc_challenge_10templates",
+        "arc_easy_10templates",
+        "bool_q_10templates",
+        "cb_10templates",
+        "cnn_dailymail_10templates",
+        "cola_10templates",
+        "common_gen_10templates",
+        "copa_10templates",
+        "coqa_10templates",
+        "cosmos_qa_10templates",
+        "dart_10templates",
+        "definite_pronoun_resolution_10templates",
+        "drop_10templates",
+        "e2e_nlg_10templates",
+        "fix_punct_10templates",
+        "gigaword_10templates",
+        "glue_mrpc_10templates",
+        "glue_qqp_10templates",
+        "hellaswag_10templates",
+        "imdb_reviews_10templates",
+        "math_dataset_10templates",
+        "mnli_matched_10templates",
+        "mnli_mismatched_10templates",
+        "multi_news_10templates",
+        "multirc_10templates",
+        "natural_questions_10templates",
+        "openbookqa_10templates",
+        "opinion_abstracts_idebate_10templates",
+        "opinion_abstracts_rotten_tomatoes_10templates",
+        "para_crawl_enes_10templates",
+        "paws_wiki_10templates",
+        "piqa_10templates",
+        "qnli_10templates",
+        "quac_10templates",
+        "record_10templates",
+        "rte_10templates",
+        "samsum_10templates",
+        "sentiment140_10templates",
+        "snli_10templates",
+        "squad_v1_10templates",
+        "squad_v2_10templates",
+        "sst2_10templates",
+        "story_cloze_10templates",
+        "stsb_10templates",
+        "trec_10templates",
+        "trivia_qa_10templates",
+        "true_case_10templates",
+        "web_nlg_en_10templates",
+        "wic_10templates",
+        "wiki_lingua_english_en_10templates",
+        "wmt14_enfr_10templates",
+        "wmt16_translate_csen_10templates",
+        "wmt16_translate_deen_10templates",
+        "wmt16_translate_fien_10templates",
+        "wmt16_translate_roen_10templates",
+        "wmt16_translate_ruen_10templates",
+        "wmt16_translate_tren_10templates",
+        "wnli_10templates",
+        "word_segment_10templates",
+        "wsc_10templates",
+        "yelp_polarity_reviews_10templates",
+    }

litgpt/data/json_data.py

@@ -0,0 +1,149 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional, Tuple, Union
+
+import torch
+from torch.utils.data import DataLoader, random_split
+
+from litgpt.data import DataModule, SFTDataset, get_sft_collate_fn
+from litgpt.prompts import PromptStyle
+from litgpt.tokenizer import Tokenizer
+from litgpt.prompts import Default
+
+
+@dataclass
+class JSON(DataModule):
+    """Loads JSON or JSONL data for supervised finetuning."""
+
+    json_path: Path
+    """A path to a JSON file or a directory with `train.json` and `val.json` containing the data.
+    The file(s) should contain a list of samples (dicts). Each dict must have the keys 'instruction' and 'output',
+    and can optionally have a key 'input' (see Alpaca)."""
+    mask_prompt: bool = False
+    """Whether to mask the prompt section from the label (with ``ignore_index``)."""
+    val_split_fraction: Optional[float] = None
+    """The fraction of the dataset to use for the validation dataset. The rest is used for training.
+    Only applies if you passed in a single file to `json_path`."""
+    prompt_style: Union[str, PromptStyle] = "default"
+    """The style to apply to instruction prompts. See `litgpt.prompts` for a list of available styles."""
+    ignore_index: int = -100
+    """The index to use for elements to be ignored in the label."""
+    seed: int = 42
+    """The random seed for creating the train/val splits and shuffling the dataset."""
+    num_workers: int = 4
+    """How many DataLoader processes to use for loading."""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, init=False, repr=False)
+    batch_size: int = field(default=1, init=False, repr=False)
+    max_seq_length: int = field(default=-1, init=False, repr=False)
+    train_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+    val_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+
+    def __post_init__(self):
+        super().__init__()
+        if self.json_path.is_file() and self.val_split_fraction is None:
+            raise ValueError(
+                "If `json_path` is a file, you must set `val_split_fraction` to a value between 0 and 1 to split the"
+                " data into train and validation sets."
+            )
+        if self.json_path.is_dir() and self.val_split_fraction is not None:
+            raise ValueError(
+                "If `json_path` is a directory, it must contain 'train.json' and 'val.json' files and"
+                f" hence `val_split_fraction` should not be set. Got `{self.val_split_fraction=}`."
+            )
+        if not self.json_path.exists():
+            raise FileNotFoundError(
+                "The `json_path` must be a file or a directory containing 'train.json' and 'val.json' files,"
+                f" but '{self.json_path!s}' does not exist."
+            )
+        if isinstance(self.prompt_style, str):
+            self.prompt_style = PromptStyle.from_name(self.prompt_style)
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.max_seq_length = -1 if max_seq_length is None else max_seq_length
+
+    def setup(self, stage: str = "") -> None:
+        train_data, test_data = self.get_splits()
+
+        self.train_dataset = SFTDataset(
+            data=train_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+        self.test_dataset = SFTDataset(
+            data=test_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+
+    def train_dataloader(self) -> DataLoader:
+        return DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            generator=torch.Generator().manual_seed(self.seed),
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+    def val_dataloader(self) -> DataLoader:
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+    def get_splits(self) -> Tuple:
+        # A single file (gets split into train and test)
+        if self.json_path.is_file():
+            data = load_split(self.json_path)
+
+            # Partition the dataset into train and test
+            train_data, test_data = random_split(
+                data,
+                [1.0 - self.val_split_fraction, self.val_split_fraction],
+                generator=torch.Generator().manual_seed(self.seed),
+            )
+            return train_data, test_data
+
+        # A directory containing train.json and val.json
+        if (train_file := self.find_split("train")) and (val_file := self.find_split("val")):
+            train_data = load_split(train_file)
+            test_data = load_split(val_file)
+            return train_data, test_data
+
+        raise FileNotFoundError(
+            "The `json_path` must be a file or a directory containing 'train.json' and 'val.json' files."
+        )
+
+    def find_split(self, split_name: str) -> Optional[Path]:
+        for suffix in (".json", ".jsonl"):
+            if (file := self.json_path / f"{split_name}{suffix}").is_file():
+                return file
+        return None
+
+
+def load_split(json_path: Path) -> Any:
+    if json_path.suffix == ".json":
+        with open(json_path, encoding="utf-8") as file:
+            return json.load(file)
+    if json_path.suffix == ".jsonl":
+        with open(json_path, encoding="utf-8") as file:
+            return [json.loads(line) for line in file]
+    else:
+        raise ValueError(f"Unsupported file format: {json_path.suffix}. Expected `.json` or `.jsonl`.")

litgpt/data/lima.py

@@ -0,0 +1,131 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+"""Implementation derived from https://github.com/tloen/alpaca-lora"""
+
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+
+import torch
+from torch.utils.data import DataLoader, random_split
+
+from litgpt.data import DataModule, SFTDataset, get_sft_collate_fn
+from litgpt.prompts import PromptStyle
+from litgpt.tokenizer import Tokenizer
+
+
+@dataclass
+class LIMA(DataModule):
+    """LIMA data module for supervised finetuning."""
+
+    mask_prompt: bool = False
+    """Whether to mask the prompt section from the label (with ``ignore_index``)."""
+    val_split_fraction: float = 0.1
+    """The fraction of the dataset to use for the validation dataset. The rest is used for training."""
+    prompt_style: Union[str, PromptStyle] = "alpaca"
+    """The style to apply to instruction prompts. See `litgpt.prompts` for a list of available styles."""
+    ignore_index: int = -100
+    """The index to use for elements to be ignored in the label."""
+    seed: int = 42
+    """The random seed for creating the train/val splits and shuffling the dataset."""
+    num_workers: int = 4
+    """How many DataLoader processes to use for loading."""
+    include_multiturn_conversations: bool = False
+    """Whether to include multi-turn conversations in the dataset."""
+    repo_id: str = "GAIR/lima"
+    """The Hugging Face dataset repository ID from where to download the data."""
+    access_token: Optional[str] = field(repr=False, default=os.getenv("HF_TOKEN"))
+    """The Hugging Face API token to use for authentication. Can also be set through the
+    `HF_TOKEN` environment variable."""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, init=False, repr=False)
+    batch_size: int = field(default=1, init=False, repr=False)
+    max_seq_length: int = field(default=-1, init=False, repr=False)
+    train_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+    test_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+
+    def __post_init__(self):
+        super().__init__()
+        if self.access_token is None:
+            raise ValueError(
+                "LIMA requires authentication, please set the `HF_TOKEN=your_token` environment"
+                " variable or pass --access_token=your_token. You can find your token by visiting"
+                " https://huggingface.co/settings/tokens"
+            )
+        if isinstance(self.prompt_style, str):
+            self.prompt_style = PromptStyle.from_name(self.prompt_style)
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.max_seq_length = -1 if max_seq_length is None else max_seq_length
+
+    def prepare_data(self) -> None:
+        from datasets import load_dataset
+
+        load_dataset(self.repo_id, token=self.access_token)
+
+    def setup(self, stage: str = "") -> None:
+        from datasets import load_dataset
+
+        dataset = load_dataset(self.repo_id, token=self.access_token)
+        data = format_dataset(dataset["train"], self.include_multiturn_conversations)
+
+        # Partition the dataset into train and test
+        train_data, test_data = random_split(
+            data,
+            [1.0 - self.val_split_fraction, self.val_split_fraction],
+            generator=torch.Generator().manual_seed(self.seed),
+        )
+        train_data, test_data = list(train_data), list(test_data)
+
+        self.train_dataset = SFTDataset(
+            data=train_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+        self.test_dataset = SFTDataset(
+            data=test_data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+        )
+
+    def train_dataloader(self) -> DataLoader:
+        return DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            shuffle=True,
+            generator=torch.Generator().manual_seed(self.seed),
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+    def val_dataloader(self) -> DataLoader:
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=False,
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+
+def format_dataset(dataset_partition: dict, include_multi_turn_conversations: bool) -> List[dict]:
+    formatted_ds = []
+
+    for entry in dataset_partition:
+        convo = entry["conversations"]
+        if include_multi_turn_conversations:
+            for i in range(0, len(convo) - 1, 2):
+                formatted_ds.append({"instruction": convo[i], "input": "", "output": convo[i + 1]})
+        else:
+            formatted_ds.append({"instruction": convo[0], "input": "", "output": convo[1]})
+
+    return formatted_ds

litgpt/data/lit_data.py

@@ -0,0 +1,64 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Tuple, Union
+
+from torch.utils.data import DataLoader
+
+from litgpt.data import DataModule
+from litgpt.tokenizer import Tokenizer
+
+
+@dataclass
+class LitData(DataModule):
+    """Loads data using LitData's StreamingDataset given a path to a folder of preprocessed data (chunks)."""
+
+    data_path: Union[str, Path] = Path("data/")
+    """The path to the data directory containing the preprocessed chunks for the streaming dataset
+    The path can also be a remote path (e.g., s3://). See also ``split_names`` if this path contains subfolders
+    for training- and validation splits."""
+    split_names: Optional[Tuple[str, str]] = None
+    """Optional tuple for names of subfolders for training and validation under ``data_path``. If not provided,
+    all data under data_path will be used for training, and the validation dataloader will be identical to the
+    train dataloader."""
+    seed: int = 42
+    """The random seed for shuffling the dataset."""
+    num_workers: int = 8
+    """How many DataLoader processes to use for loading."""
+
+    batch_size: int = field(init=False, repr=False, default=1)
+    seq_length: int = field(init=False, repr=False, default=2048)
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        if self.split_names is not None and len(self.split_names) != 2:
+            raise ValueError("If provided `split_names` must be a tuple of two strings, for example: ('train', 'val').")
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.batch_size = batch_size
+        self.seq_length = max_seq_length + 1  # Increase by one because we need the next token as well
+
+    def train_dataloader(self) -> DataLoader:
+        input_dir = os.path.join(self.data_path, self.split_names[0]) if self.split_names else str(self.data_path)
+        return self._dataloader(input_dir=input_dir, train=True)
+
+    def val_dataloader(self) -> DataLoader:
+        input_dir = os.path.join(self.data_path, self.split_names[1]) if self.split_names else str(self.data_path)
+        return self._dataloader(input_dir=input_dir, train=False)
+
+    def _dataloader(self, input_dir: str, train: bool):
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        dataset = StreamingDataset(
+            input_dir=input_dir,
+            item_loader=TokensLoader(block_size=self.seq_length),
+            shuffle=train,
+            seed=self.seed,
+        )
+        dataloader = StreamingDataLoader(
+            dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return dataloader

litgpt/data/longform.py

@@ -0,0 +1,90 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Union
+
+import torch
+from torch.utils.data import DataLoader
+
+from litgpt.data import DataModule, SFTDataset, get_sft_collate_fn
+from litgpt.data.alpaca import download_if_missing
+from litgpt.prompts import PromptStyle
+from litgpt.tokenizer import Tokenizer
+
+_URL = "https://raw.githubusercontent.com/akoksal/LongForm/main/dataset"
+
+
+@dataclass
+class LongForm(DataModule):
+    """LongForm data module for supervised finetuning."""
+
+    mask_prompt: bool = False
+    """Whether to mask the prompt section from the label (with ``ignore_index``)."""
+    prompt_style: Union[str, PromptStyle] = "longform"
+    """The style to apply to instruction prompts. See `litgpt.prompts` for a list of available styles."""
+    ignore_index: int = -100
+    """The index to use for elements to be ignored in the label."""
+    seed: int = 42
+    """The random seed for shuffling the dataset."""
+    num_workers: int = 4
+    """How many DataLoader processes to use for loading."""
+    download_dir: Path = Path("./data/longform")
+    """The directory in which the downloaded dataset gets saved."""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, init=False, repr=False)
+    batch_size: int = field(default=1, init=False, repr=False)
+    max_seq_length: int = field(default=-1, init=False, repr=False)
+    train_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+    test_dataset: Optional[SFTDataset] = field(default=None, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        if isinstance(self.prompt_style, str):
+            self.prompt_style = PromptStyle.from_name(self.prompt_style)
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.max_seq_length = -1 if max_seq_length is None else max_seq_length
+
+    def prepare_data(self) -> None:
+        self.download_dir.mkdir(parents=True, exist_ok=True)
+        download_if_missing(self.download_dir / "train.json", f"{_URL}/train.json")
+        download_if_missing(self.download_dir / "val.json", f"{_URL}/val.json")
+
+    def train_dataloader(self):
+        return self._dataloader("train")
+
+    def val_dataloader(self):
+        return self._dataloader("val")
+
+    def _dataloader(self, split: str) -> DataLoader:
+        with open(self.download_dir / f"{split}.json", encoding="utf-8") as file:
+            data = json.load(file)
+
+        dataset = SFTDataset(
+            data=data,
+            tokenizer=self.tokenizer,
+            prompt_style=self.prompt_style,
+            max_seq_length=self.max_seq_length,
+            mask_prompt=self.mask_prompt,
+            ignore_index=self.ignore_index,
+            transform=_transform,
+        )
+        return DataLoader(
+            dataset=dataset,
+            batch_size=self.batch_size,
+            shuffle=(split == "train"),
+            generator=torch.Generator().manual_seed(self.seed),
+            num_workers=self.num_workers,
+            collate_fn=get_sft_collate_fn(max_seq_length=self.max_seq_length, ignore_index=self.ignore_index),
+        )
+
+
+def _transform(item: dict) -> dict:
+    item["instruction"] = item.pop("input")
+    return item

litgpt/data/microllama.py

@@ -0,0 +1,14 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Union
+
+from litgpt.data.tinyllama import TinyLlama
+
+
+@dataclass
+class MicroLlama(TinyLlama):
+    """The MicroLlama data module is composed of only SlimPajama data."""
+
+    def __init__(self, data_path: Union[str, Path] = Path("data/"), seed: int = 42, num_workers: int = 8):
+        super().__init__(data_path=data_path, seed=seed, num_workers=num_workers, use_starcoder=False)

litgpt/data/openwebtext.py

@@ -0,0 +1,107 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import os
+from dataclasses import dataclass, field
+from functools import partial
+from pathlib import Path
+from typing import Optional, Union
+
+from torch.utils.data import DataLoader
+
+from litgpt.data import DataModule
+from litgpt.tokenizer import Tokenizer
+
+
+@dataclass
+class OpenWebText(DataModule):
+    """The OpenWebText data module for pretraining."""
+
+    data_path: Union[str, Path] = Path("data/openwebtext")
+    """The path to the data directory, containing two folders 'train' and 'val'
+    which are the output of the preprocessing step. The path can also be a remote path (e.g., s3://)."""
+    val_split_fraction: float = 0.0005
+    """The fraction of data that should be put aside for validation."""
+    seed: int = 42
+    """The seed to use for shuffling the training data."""
+    num_workers: int = 8
+    """The number of workers to use for the dataloaders."""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, repr=False, init=False)
+    batch_size: int = field(default=1, repr=False, init=False)
+    seq_length: int = field(default=2048, repr=False, init=False)
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        # Could be a remote path (s3://) or a local path
+        self.data_path_train = str(self.data_path).rstrip("/") + "/train"
+        self.data_path_val = str(self.data_path).rstrip("/") + "/val"
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = 2048
+    ) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.seq_length = max_seq_length + 1  # Increase by one because we need the next token as well
+
+    def prepare_data(self) -> None:
+        from datasets import Dataset, load_dataset
+        from litdata import optimize
+
+        if str(self.data_path).startswith("s3://"):
+            print(f"The OpenWebText data path points to an S3 location: {self.data_path}. Skipping preprocessing.")
+            return
+
+        if Path(self.data_path_train).is_dir() and Path(self.data_path_val).is_dir():
+            print(f"Found OpenWebText train and val dir: {self.data_path}. Skipping preprocessing.")
+            return
+
+        dataset = load_dataset("openwebtext", num_proc=(os.cpu_count() // 2), trust_remote_code=True)
+
+        # Split the data in training and validation
+        split_dataset = dataset["train"].train_test_split(
+            test_size=self.val_split_fraction, seed=self.seed, shuffle=True
+        )
+        split_dataset["val"] = split_dataset.pop("test")  # rename the test split to val
+
+        def tokenize(data: Dataset, index: int):
+            yield self.tokenizer.encode(data[index]["text"], eos=True)
+
+        optimize(
+            fn=partial(tokenize, split_dataset["train"]),
+            inputs=list(range(len(split_dataset["train"]))),
+            output_dir=self.data_path_train,
+            num_workers=min(64, os.cpu_count() - 1),
+            chunk_bytes="200MB",
+        )
+        optimize(
+            fn=partial(tokenize, split_dataset["val"]),
+            inputs=list(range(len(split_dataset["val"]))),
+            output_dir=self.data_path_val,
+            num_workers=min(8, os.cpu_count() - 1),
+            chunk_bytes="200MB",
+        )
+
+    def train_dataloader(self) -> DataLoader:
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        train_dataset = StreamingDataset(
+            input_dir=self.data_path_train,
+            item_loader=TokensLoader(block_size=self.seq_length),
+            shuffle=True,
+        )
+        train_dataloader = StreamingDataLoader(
+            train_dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return train_dataloader
+
+    def val_dataloader(self) -> DataLoader:
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        val_dataset = StreamingDataset(
+            input_dir=self.data_path_val,
+            item_loader=TokensLoader(block_size=self.seq_length),
+            shuffle=True,
+        )
+        val_dataloader = StreamingDataLoader(
+            val_dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return val_dataloader

litgpt/data/prepare_arxiv.py

@@ -0,0 +1,62 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import json
+import os
+import time
+from pathlib import Path
+
+from litgpt.data.prepare_starcoder import DataChunkRecipe
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import CLI, extend_checkpoint_dir
+
+
+class ArxivDataRecipe(DataChunkRecipe):
+    is_generator = True
+
+    def __init__(self, tokenizer: Tokenizer, chunk_size: int):
+        super().__init__(chunk_size)
+        self.tokenizer = tokenizer
+
+    def prepare_structure(self, input_dir):
+        files = Path(input_dir).rglob("*.jsonl")
+        return [str(file) for file in files]
+
+    def prepare_item(self, filepath):
+        with open(filepath, "r", encoding="utf-8") as f:
+            for row in f:
+                obj = json.loads(row)
+                text = obj["text"]
+                text_ids = self.tokenizer.encode(string=text, bos=False, eos=True)
+                yield text_ids
+
+
+def prepare(
+    input_dir: Path = Path("data/arxiv_split/2407/train"),
+    output_dir: Path = Path("data/arxiv/2407/train"),
+    tokenizer_path: Path = Path("checkpoints/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T"),
+    chunk_size: int = (2049 * 16384),
+    fast_dev_run: bool = False,
+) -> None:
+    from litdata.processing.data_processor import DataProcessor
+    from litdata.streaming import TokensLoader
+
+    tokenizer_path = extend_checkpoint_dir(tokenizer_path)
+    tokenizer = Tokenizer(tokenizer_path)
+    data_recipe = ArxivDataRecipe(tokenizer=tokenizer, chunk_size=chunk_size)
+    data_processor = DataProcessor(
+        input_dir=str(input_dir),
+        output_dir=str(output_dir),
+        fast_dev_run=fast_dev_run,
+        num_workers=1,
+        item_loader=TokensLoader(),
+        num_downloaders=1,
+    )
+
+    start_time = time.time()
+    data_processor.run(data_recipe)
+    elapsed_time = time.time() - start_time
+    print(f"Time taken: {elapsed_time:.2f} seconds")
+
+
+if __name__ == "__main__":
+    CLI(prepare)

litgpt/data/prepare_slimpajama.py

@@ -0,0 +1,63 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import json
+import os
+import time
+from pathlib import Path
+
+from litgpt.data.prepare_starcoder import DataChunkRecipe
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import CLI, extend_checkpoint_dir
+
+
+class SlimPajamaDataRecipe(DataChunkRecipe):
+    is_generator = True
+
+    def __init__(self, tokenizer: Tokenizer, chunk_size: int):
+        super().__init__(chunk_size)
+        self.tokenizer = tokenizer
+
+    def prepare_structure(self, input_dir):
+        files = Path(input_dir).rglob("*.zst")
+        return [str(file) for file in files]
+
+    def prepare_item(self, filepath):
+        import zstandard as zstd
+
+        with zstd.open(open(filepath, "rb"), "rt", encoding="utf-8") as f:
+            for row in f:
+                text = json.loads(row)["text"]
+                if json.loads(row)["meta"]["redpajama_set_name"] == "RedPajamaGithub":
+                    continue  # exclude the GitHub data since it overlaps with starcoder
+                text_ids = self.tokenizer.encode(string=text, bos=False, eos=True)
+                yield text_ids
+
+
+def prepare(
+    input_dir: Path = Path("data/SlimPajama-627B/train"),
+    output_dir: Path = Path("data/slimpajama/train"),
+    tokenizer_path: Path = Path("checkpoints/Llama-2-7b-hf/"),
+    chunk_size: int = (2049 * 16384),
+    fast_dev_run: bool = False,
+) -> None:
+    from litdata.processing.data_processor import DataProcessor
+
+    tokenizer_path = extend_checkpoint_dir(tokenizer_path)
+    tokenizer = Tokenizer(tokenizer_path)
+    data_recipe = SlimPajamaDataRecipe(tokenizer=tokenizer, chunk_size=chunk_size)
+    data_processor = DataProcessor(
+        input_dir=str(input_dir),
+        output_dir=str(output_dir),
+        fast_dev_run=fast_dev_run,
+        num_workers=os.cpu_count(),
+        num_downloaders=1,
+    )
+
+    start_time = time.time()
+    data_processor.run(data_recipe)
+    elapsed_time = time.time() - start_time
+    print(f"Time taken: {elapsed_time:.2f} seconds")
+
+
+if __name__ == "__main__":
+    CLI(prepare)

litgpt/data/prepare_starcoder.py

@@ -0,0 +1,81 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import os
+import time
+import traceback
+from pathlib import Path
+
+from lightning_utilities.core.imports import RequirementCache
+
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import CLI, extend_checkpoint_dir
+
+_LITDATA_AVAILABLE = RequirementCache("litdata")
+if _LITDATA_AVAILABLE:
+    from litdata.processing.data_processor import DataChunkRecipe
+else:
+    DataChunkRecipe = object
+
+
+class StarcoderDataRecipe(DataChunkRecipe):
+    is_generator = True
+
+    def __init__(self, tokenizer: Tokenizer, chunk_size: int):
+        super().__init__(chunk_size)
+        self.tokenizer = tokenizer
+
+    def prepare_structure(self, input_dir):
+        files = Path(input_dir).rglob("*.parquet")
+        return [str(file) for file in files]
+
+    def prepare_item(self, item_metadata):
+        import pyarrow.parquet as pq
+
+        filepath = item_metadata
+        start = time.time()
+
+        try:
+            parquet_file = pq.ParquetFile(filepath)
+            # reduce RAM usage
+            for batch in parquet_file.iter_batches(batch_size=8192, columns=["content"]):
+                for text in batch.to_pandas()["content"]:
+                    yield self.tokenizer.encode(text, bos=False, eos=True)
+
+        except Exception:
+            print(traceback.format_exc())
+            print(f"Error reading {filepath}")
+            return
+
+        parquet_file.close()
+        end = time.time()
+        print(f"Took {end - start:.2f} seconds total", filepath)
+
+
+def prepare(
+    input_dir: Path = Path("data/starcoderdata"),
+    output_dir: Path = Path("data/starcoder"),
+    tokenizer_path: Path = Path("checkpoints/Llama-2-7b-hf/"),
+    chunk_size: int = (2049 * 8192),
+    fast_dev_run: bool = False,
+) -> None:
+    from litdata.processing.data_processor import DataProcessor
+
+    tokenizer_path = extend_checkpoint_dir(tokenizer_path)
+    tokenizer = Tokenizer(tokenizer_path)
+    data_recipe = StarcoderDataRecipe(tokenizer=tokenizer, chunk_size=chunk_size)
+    data_processor = DataProcessor(
+        input_dir=str(input_dir),
+        output_dir=str(output_dir),
+        fast_dev_run=fast_dev_run,
+        num_workers=os.cpu_count(),
+        num_downloaders=1,
+    )
+
+    start_time = time.time()
+    data_processor.run(data_recipe)
+    elapsed_time = time.time() - start_time
+    print(f"Time taken: {elapsed_time:.2f} seconds")
+
+
+if __name__ == "__main__":
+    CLI(prepare)

litgpt/data/sharding.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+import os
+
+# 根目录：指向 arxiv_split
+processed_base = './litgpt/data/arxiv_split'
+# 每个分片约 16MB
+chunk_size_bytes = 16 * 1024 * 1024
+
+for month in os.listdir(processed_base):
+    month_dir = os.path.join(processed_base, month)
+    if not os.path.isdir(month_dir):
+        continue
+
+    for split in ('train', 'val'):
+        # 原地切片：直接在 split 目录下写 chunk_*.jsonl
+        src_dir  = os.path.join(month_dir, split)
+        src_file = os.path.join(src_dir, f'{month}_{split}.jsonl')
+        if not os.path.isfile(src_file):
+            print(f'[跳过] 找不到 {src_file}')
+            continue
+
+        out_dir = src_dir  # 就在原目录下输出
+        # （src_dir 肯定存在，无需再创建）
+
+        print(f'[{month}/{split}] 在 {out_dir} 目录开始切分…')
+        chunk_idx = 0
+        cur_size  = 0
+        out_path  = os.path.join(out_dir, f'chunk_{chunk_idx:03d}.jsonl')
+        out_f     = open(out_path, 'w', encoding='utf-8')
+
+        with open(src_file, 'r', encoding='utf-8') as rf:
+            for line in rf:
+                line_bytes = len(line.encode('utf-8'))
+                if cur_size + line_bytes > chunk_size_bytes and cur_size > 0:
+                    out_f.close()
+                    chunk_idx += 1
+                    cur_size = 0
+                    out_path = os.path.join(out_dir, f'chunk_{chunk_idx:03d}.jsonl')
+                    out_f = open(out_path, 'w', encoding='utf-8')
+
+                out_f.write(line)
+                cur_size += line_bytes
+
+        out_f.close()
+        print(f'[{month}/{split}] 切分完成，共 {chunk_idx+1} 个分片。\n')

litgpt/data/split_trainval.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+import os
+import random
+
+# 配置区
+processed_base = './litgpt/data/arxiv_processed'
+output_base    = './litgpt/data/arxiv_split'
+split_ratio    = 0.01   # 验证集比例
+seed           = 42     # 随机种子
+
+random.seed(seed)
+
+# 遍历每个子目录
+for month in os.listdir(processed_base):
+    src_dir = os.path.join(processed_base, month)
+    if not os.path.isdir(src_dir):
+        continue
+
+    src_file = os.path.join(src_dir, f'{month}.jsonl')
+    if not os.path.isfile(src_file):
+        print(f'[跳过] 找不到文件 {src_file}')
+        continue
+
+    # 1) 统计行数
+    print(f'[{month}] 统计总行数…')
+    with open(src_file, 'r', encoding='utf-8') as f:
+        total = sum(1 for _ in f)
+
+    n_val = int(total * split_ratio)
+    print(f'[{month}] 总行数={total}，验证集行数={n_val}')
+
+    # 2) 随机抽样验证集索引
+    val_idx = set(random.sample(range(total), n_val))
+
+    # 3) 准备输出目录
+    out_dir = os.path.join(output_base, month)
+    os.makedirs(out_dir, exist_ok=True)
+    train_dir = os.path.join(out_dir, 'train')
+    val_dir = os.path.join(out_dir, 'val')
+    os.makedirs(train_dir, exist_ok=True)
+    os.makedirs(val_dir, exist_ok=True)
+    train_path = os.path.join(train_dir, f'{month}_train.jsonl')
+    val_path   = os.path.join(val_dir, f'{month}_val.jsonl')
+
+    # 4) 写入训练/验证文件
+    print(f'[{month}] 开始切分并写入到 {out_dir} …')
+    with open(src_file, 'r', encoding='utf-8') as rf, \
+         open(train_path, 'w', encoding='utf-8') as tf, \
+         open(val_path,   'w', encoding='utf-8') as vf:
+
+        for i, line in enumerate(rf):
+            if i in val_idx:
+                vf.write(line)
+            else:
+                tf.write(line)
+
+    print(f'[{month}] 完成：train -> {train_path}，val -> {val_path}\n')
+

litgpt/data/text_files.py

@@ -0,0 +1,148 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import glob
+import os
+from dataclasses import dataclass, field
+from functools import partial
+from pathlib import Path
+from typing import Optional
+
+from torch.utils.data import DataLoader
+
+from litgpt.data import DataModule
+from litgpt.tokenizer import Tokenizer
+
+
+@dataclass
+class TextFiles(DataModule):
+    """The TextFile data module used for pretraining.
+
+    Reads in text data from plaintext files contained in a data folder
+    and provides training and validation dataloaders that return batches of tokens.
+    Every sample is set to a fixed length.
+    """
+
+    train_data_path: Path
+    """The path to the data directory used for training that contains .txt files"""
+    val_data_path: Optional[Path] = None
+    """The path to the data directory used for validation that
+    contains .txt files. Splits off data for validation from the
+    training set if None."""
+    seed: int = 42
+    """The seed to use for shuffling the dataset."""
+    num_workers: int = 4
+    """The number of workers to use for data loading."""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, init=False, repr=False)
+    batch_size: int = field(default=1, init=False, repr=False)
+    max_seq_length: int = field(default=-1, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        self.out_path_train = self.train_data_path / "train"
+        if self.val_data_path is None:
+            self.out_path_val = self.train_data_path / "val"
+        else:
+            self.out_path_val = Path(self.val_data_path) / "val"
+
+    def connect(self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: int = -1) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.max_seq_length = max_seq_length + 1  # Increase by one because we need the next token as well
+
+    def prepare_data(self) -> None:
+        from litdata import optimize
+        from litdata.streaming import TokensLoader
+
+        train_files = sorted(glob.glob(str(self.train_data_path / "*.txt")))
+        assert len(train_files) > 0, f"No .txt files found in train data {train_files}"
+
+        if self.val_data_path is not None:
+            self.val_data_path = Path(self.val_data_path)
+            val_files = sorted(glob.glob(str(self.val_data_path / "*.txt")))
+            assert len(val_files) > 0, f"No .txt files found in validation data {val_files}"
+        # train/test split. let's use only shard 0 for test split, rest train
+        else:
+            assert len(train_files) > 1, f"Expected at least two .txt files in {train_files}"
+            val_files, *train_files = train_files
+            val_files = [val_files]
+
+        # It's ok to use almost all CPUs here because this runs in a single process
+        num_workers = os.cpu_count() - 1
+        use_workers = min(num_workers, len(train_files))
+        if not Path(self.out_path_train).is_dir():
+            validate_tokenizer(self.tokenizer)
+            optimize(
+                fn=partial(tokenize, tokenizer=self.tokenizer),
+                inputs=train_files,
+                output_dir=str(self.out_path_train),
+                num_workers=use_workers,
+                chunk_bytes="50MB",
+                item_loader=TokensLoader(block_size=self.max_seq_length),
+            )
+        else:
+            print(
+                f"\nWarning: Preprocessed training data found in {self.out_path_train}."
+                " For efficiency, reprocessing is skipped. If your text input has changed since"
+                " the last `litgpt pretrain` command, remove the preprocessed file(s) to trigger"
+                f" reprocessing: `rm -rf {self.out_path_train}`\n"
+            )
+        use_workers = min(num_workers, len(val_files))
+        if not Path(self.out_path_val).is_dir():
+            validate_tokenizer(self.tokenizer)
+            optimize(
+                fn=partial(tokenize, tokenizer=self.tokenizer),
+                inputs=val_files,
+                output_dir=str(self.out_path_val),
+                num_workers=use_workers,
+                chunk_bytes="50MB",
+                item_loader=TokensLoader(block_size=self.max_seq_length),
+            )
+        else:
+            print(
+                f"\nWarning: Preprocessed validation data found in {self.out_path_val}."
+                " For efficiency, reprocessing is skipped. If your text input has changed since"
+                " the last `litgpt pretrain` command, remove the preprocessed file(s) to trigger"
+                f" reprocessing: `rm -rf {self.out_path_val}`\n"
+            )
+
+    def train_dataloader(self) -> DataLoader:
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        train_dataset = StreamingDataset(
+            input_dir=str(self.out_path_train),
+            item_loader=TokensLoader(block_size=self.max_seq_length),
+            shuffle=True,
+        )
+
+        train_dataloader = StreamingDataLoader(
+            train_dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return train_dataloader
+
+    def val_dataloader(self) -> DataLoader:
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        val_dataset = StreamingDataset(
+            input_dir=str(self.out_path_val),
+            item_loader=TokensLoader(block_size=self.max_seq_length),
+            shuffle=True,
+        )
+        val_dataloader = StreamingDataLoader(
+            val_dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return val_dataloader
+
+
+def tokenize(filename: str, tokenizer: Tokenizer):
+    with open(filename, encoding="utf-8") as file:
+        text = file.read()
+    text = text.strip()
+    yield tokenizer.encode(text, bos=True, eos=False)
+
+
+def validate_tokenizer(tokenizer: Tokenizer) -> None:
+    if tokenizer is None:
+        raise ValueError(
+            "Tokenizer is None. If you are using this data module via `litgpt pretrain`, "
+            "please provide a valid `--tokenizer_dir` path."
+        )

litgpt/data/tinyllama.py

@@ -0,0 +1,103 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional, Union
+
+from torch.utils.data import DataLoader
+
+from litgpt.data import DataModule
+from litgpt.tokenizer import Tokenizer
+
+
+@dataclass
+class TinyLlama(DataModule):
+    """The TinyLlama data module is composed of a mix of SlimPajama and Starcoder data.
+
+    Provides training and validation streaming dataloaders that return batches of tokens.
+    """
+
+    data_path: Union[str, Path] = Path("data/")
+    """The path to the data directory, containing two folders 'slimpajama' and 'starcoder'
+    which are the output of the preprocessing step done in advance. See the `tutorial/pretrain_tinyllama.md`
+    for instructions. The path can also be a remote path (e.g., s3://)."""
+    seed: int = 42
+    """The random seed for shuffling the dataset."""
+    num_workers: int = 8
+    """How many DataLoader processes to use for loading."""
+    use_starcoder: bool = True
+    """Toggle for using Starcoder data."""
+
+    batch_size: int = field(init=False, repr=False, default=1)
+    seq_length: int = field(init=False, repr=False, default=2048)
+
+    def __post_init__(self):
+        super().__init__()
+        # Could be a remote path (s3://) or a local path
+        self.slimpajama_train = str(self.data_path).rstrip("/") + "/slimpajama/train"
+        self.slimpajama_val = str(self.data_path).rstrip("/") + "/slimpajama/val"
+        self.required_paths = [self.slimpajama_train, self.slimpajama_val]
+
+        if self.use_starcoder:
+            self.starcoder_train = str(self.data_path).rstrip("/") + "/starcoder"
+            self.required_paths += [self.starcoder_train]
+
+    def connect(
+        self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: Optional[int] = None
+    ) -> None:
+        self.batch_size = batch_size
+        self.seq_length = max_seq_length + 1  # Increase by one because we need the next token as well
+
+    def prepare_data(self) -> None:
+        for path in self.required_paths:
+            if not path.startswith("s3://") and not Path(path).is_dir():
+                raise FileNotFoundError(
+                    "The data path for TinyLlama is expected to be the directory containing these subdirectories:"
+                    f" `slimpajama/train`, `slimpajama/val`, `starcoder`. The directory {path} does not exist."
+                    " Set it via `--data.data_path=...`"
+                )
+
+    def train_dataloader(self) -> DataLoader:
+        from litdata.streaming import CombinedStreamingDataset, StreamingDataLoader, StreamingDataset, TokensLoader
+
+        slim_train_data = StreamingDataset(
+            input_dir=self.slimpajama_train,
+            item_loader=TokensLoader(block_size=self.seq_length),
+            shuffle=True,
+            drop_last=True,
+        )
+        train_data = slim_train_data
+
+        if self.use_starcoder:
+            train_datasets = [
+                slim_train_data,
+                StreamingDataset(
+                    input_dir=self.starcoder_train,
+                    item_loader=TokensLoader(block_size=self.seq_length),
+                    shuffle=True,
+                    drop_last=True,
+                ),
+            ]
+
+            # Mix SlimPajama data and Starcoder data with these proportions:
+            weights = (0.693584, 0.306416)
+            train_data = CombinedStreamingDataset(
+                datasets=train_datasets, seed=self.seed, weights=weights, iterate_over_all=False
+            )
+
+        train_dataloader = StreamingDataLoader(
+            train_data, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return train_dataloader
+
+    def val_dataloader(self) -> DataLoader:
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        val_dataset = StreamingDataset(
+            input_dir=self.slimpajama_val,
+            item_loader=TokensLoader(block_size=self.seq_length),
+            shuffle=True,
+        )
+        val_dataloader = StreamingDataLoader(
+            val_dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return val_dataloader

litgpt/data/tinystories.py

@@ -0,0 +1,141 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import glob
+import json
+import os
+from dataclasses import dataclass, field
+from functools import partial
+from pathlib import Path
+from typing import Optional
+
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from litgpt.data import DataModule
+from litgpt.data.alpaca import download_if_missing
+from litgpt.data.text_files import validate_tokenizer
+from litgpt.tokenizer import Tokenizer
+
+
+@dataclass
+class TinyStories(DataModule):
+    """The TinyStories data module: https://huggingface.co/datasets/roneneldan/TinyStories
+
+    Provides training and validation dataloaders that return batches of tokens. Every sample is set to a fixed length.
+    """
+
+    data_path: Path = Path("data/tinystories")
+    """The path to the data directory, containing two folders 'train' and 'val'
+    which are the output of the preprocessing step."""
+    seed: int = 42
+    """The seed to use for shuffling the dataset."""
+    num_workers: int = 8
+    """The number of workers to use for the dataloaders."""
+
+    tokenizer: Optional[Tokenizer] = field(default=None, init=False, repr=False)
+    batch_size: int = field(default=1, init=False, repr=False)
+    max_seq_length: int = field(default=-1, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        super().__init__()
+        self.data_path_train = self.data_path / "train"
+        self.data_path_val = self.data_path / "val"
+
+    def connect(self, tokenizer: Optional[Tokenizer] = None, batch_size: int = 1, max_seq_length: int = -1) -> None:
+        self.tokenizer = tokenizer
+        self.batch_size = batch_size
+        self.max_seq_length = max_seq_length + 1  # Increase by one because we need the next token as well
+
+    def prepare_data(self) -> None:
+        from litdata import optimize
+
+        download(self.data_path)
+
+        files = sorted(glob.glob(str(self.data_path / "TinyStories_all_data" / "*.json")))
+        assert len(files) > 0, f"No json files found in {files}"
+        assert len(files) > 1, f"Expected at least two json files in {files}"
+        # train/test split. let's use only shard 0 for test split, rest train
+        val_file, *train_files = files
+        num_workers = os.cpu_count() - 1
+
+        if not Path(self.data_path_train).is_dir():
+            validate_tokenizer(self.tokenizer)
+            optimize(
+                fn=partial(tokenize, tokenizer=self.tokenizer),
+                inputs=train_files,
+                output_dir=str(self.data_path_train),
+                num_workers=num_workers,
+                chunk_bytes="200MB",
+            )
+        if not Path(self.data_path_val).is_dir():
+            validate_tokenizer(self.tokenizer)
+            optimize(
+                fn=partial(tokenize, tokenizer=self.tokenizer),
+                inputs=[val_file],
+                output_dir=str(self.data_path_val),
+                num_workers=1,  # there's only 1 file
+                chunk_bytes="200MB",
+            )
+
+    def train_dataloader(self) -> DataLoader:
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        train_dataset = StreamingDataset(
+            input_dir=str(self.data_path_train),
+            item_loader=TokensLoader(block_size=self.max_seq_length),
+            shuffle=True,
+        )
+        train_dataloader = StreamingDataLoader(
+            train_dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return train_dataloader
+
+    def val_dataloader(self) -> DataLoader:
+        from litdata.streaming import StreamingDataLoader, StreamingDataset, TokensLoader
+
+        val_dataset = StreamingDataset(
+            input_dir=str(self.data_path_val),
+            item_loader=TokensLoader(block_size=self.max_seq_length),
+            shuffle=True,
+        )
+        val_dataloader = StreamingDataLoader(
+            val_dataset, batch_size=self.batch_size, pin_memory=True, num_workers=self.num_workers, drop_last=True
+        )
+        return val_dataloader
+
+
+def tokenize(filename: str, tokenizer: Tokenizer):
+    with open(filename, encoding="utf-8") as f:
+        data = json.load(f)
+    global_rank = int(os.environ["DATA_OPTIMIZER_GLOBAL_RANK"])
+    num_workers = int(os.environ["DATA_OPTIMIZER_NUM_WORKERS"])
+    local_rank = global_rank % num_workers
+    for example in tqdm(data, position=local_rank):
+        text = example["story"]
+        text = text.strip()  # get rid of leading/trailing whitespace
+        tokens = tokenizer.encode(text, bos=True, eos=False)  # encode the text, use BOS
+        yield tokens
+
+
+_URL = "https://huggingface.co/datasets/roneneldan/TinyStories/resolve/main/TinyStories_all_data.tar.gz"
+
+
+def download(data_dir: Path):
+    data_dir.mkdir(exist_ok=True, parents=True)
+
+    data_tar = data_dir / "TinyStories_all_data.tar.gz"
+    data_dir = data_dir / "TinyStories_all_data"
+    shard_filenames = sorted(glob.glob(str(data_dir / "*.json")))
+    if shard_filenames:
+        print(f"{data_dir} already exists, skipping unpacking...")
+        return
+
+    # download the TinyStories dataset, unless it's already downloaded
+    download_if_missing(data_tar, _URL, stream=True, mode="wb")
+
+    # unpack the tar.gz file into all the data shards (json files)
+    data_dir.mkdir(exist_ok=False)
+    tar_command = f"tar -xzf {data_tar} -C {data_dir}"
+    print(tar_command)
+    os.system(tar_command)
+    shard_filenames = sorted(glob.glob(str(data_dir / "*.json")))
+    print(f"Number of shards: {len(shard_filenames)}")

litgpt/deploy/serve.py

@@ -0,0 +1,308 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import json
+import sys
+from pathlib import Path
+from pprint import pprint
+from typing import Any, Dict, Literal, Optional
+
+import torch
+from lightning_utilities.core.imports import RequirementCache
+
+from litgpt.api import LLM
+from litgpt.utils import auto_download_checkpoint
+
+_LITSERVE_AVAILABLE = RequirementCache("litserve")
+_JINJA2_AVAILABLE = RequirementCache("jinja2")
+if _LITSERVE_AVAILABLE:
+    from litserve import LitAPI, LitServer
+    from litserve.specs.openai import ChatCompletionRequest, OpenAISpec
+else:
+    LitAPI, LitServer = object, object
+
+
+class BaseLitAPI(LitAPI):
+    def __init__(
+        self,
+        checkpoint_dir: Path,
+        quantize: Optional[Literal["bnb.nf4", "bnb.nf4-dq", "bnb.fp4", "bnb.fp4-dq", "bnb.int8"]] = None,
+        precision: Optional[str] = None,
+        temperature: float = 0.8,
+        top_k: int = 50,
+        top_p: float = 1.0,
+        max_new_tokens: int = 50,
+        devices: int = 1,
+        api_path: Optional[str] = None,
+    ) -> None:
+        if not _LITSERVE_AVAILABLE:
+            raise ImportError(str(_LITSERVE_AVAILABLE))
+
+        super().__init__(api_path=api_path)
+
+        self.checkpoint_dir = checkpoint_dir
+        self.quantize = quantize
+        self.precision = precision
+        self.temperature = temperature
+        self.top_k = top_k
+        self.max_new_tokens = max_new_tokens
+        self.top_p = top_p
+        self.devices = devices
+
+    def setup(self, device: str) -> None:
+        if ":" in device:
+            accelerator, device = device.split(":")
+            device = f"[{int(device)}]"
+        else:
+            accelerator = device
+            device = 1
+
+        print("Initializing model...", file=sys.stderr)
+        self.llm = LLM.load(model=self.checkpoint_dir, distribute=None)
+
+        self.llm.distribute(
+            devices=self.devices,
+            accelerator=accelerator,
+            quantize=self.quantize,
+            precision=self.precision,
+            generate_strategy=("sequential" if self.devices is not None and self.devices > 1 else None),
+        )
+        print("Model successfully initialized.", file=sys.stderr)
+
+    def decode_request(self, request: Dict[str, Any]) -> Any:
+        prompt = str(request["prompt"])
+        return prompt
+
+
+class SimpleLitAPI(BaseLitAPI):
+    def __init__(
+        self,
+        checkpoint_dir: Path,
+        quantize: Optional[str] = None,
+        precision: Optional[str] = None,
+        temperature: float = 0.8,
+        top_k: int = 50,
+        top_p: float = 1.0,
+        max_new_tokens: int = 50,
+        devices: int = 1,
+        api_path: Optional[str] = None,
+    ):
+        super().__init__(
+            checkpoint_dir,
+            quantize,
+            precision,
+            temperature,
+            top_k,
+            top_p,
+            max_new_tokens,
+            devices,
+            api_path=api_path,
+        )
+
+    def setup(self, device: str):
+        super().setup(device)
+
+    def predict(self, inputs: str) -> Any:
+        output = self.llm.generate(
+            inputs,
+            temperature=self.temperature,
+            top_k=self.top_k,
+            top_p=self.top_p,
+            max_new_tokens=self.max_new_tokens,
+        )
+        return output
+
+    def encode_response(self, output: str) -> Dict[str, Any]:
+        # Convert the model output to a response payload.
+        return {"output": output}
+
+
+class StreamLitAPI(BaseLitAPI):
+    def __init__(
+        self,
+        checkpoint_dir: Path,
+        quantize: Optional[str] = None,
+        precision: Optional[str] = None,
+        temperature: float = 0.8,
+        top_k: int = 50,
+        top_p: float = 1.0,
+        max_new_tokens: int = 50,
+        devices: int = 1,
+        api_path: Optional[str] = None,
+    ):
+        super().__init__(
+            checkpoint_dir,
+            quantize,
+            precision,
+            temperature,
+            top_k,
+            top_p,
+            max_new_tokens,
+            devices,
+            api_path=api_path,
+        )
+
+    def setup(self, device: str):
+        super().setup(device)
+
+    def predict(self, inputs: torch.Tensor) -> Any:
+        yield from self.llm.generate(
+            inputs,
+            temperature=self.temperature,
+            top_k=self.top_k,
+            top_p=self.top_p,
+            max_new_tokens=self.max_new_tokens,
+            stream=True,
+        )
+
+    def encode_response(self, output):
+        for out in output:
+            yield {"output": out}
+
+
+class OpenAISpecLitAPI(BaseLitAPI):
+    def __init__(
+        self,
+        checkpoint_dir: Path,
+        quantize: Optional[str] = None,
+        precision: Optional[str] = None,
+        temperature: float = 0.8,
+        top_k: int = 50,
+        top_p: float = 1.0,
+        max_new_tokens: int = 50,
+        devices: int = 1,
+        api_path: Optional[str] = None,
+    ):
+        super().__init__(
+            checkpoint_dir,
+            quantize,
+            precision,
+            temperature,
+            top_k,
+            top_p,
+            max_new_tokens,
+            devices,
+            api_path=api_path,
+        )
+
+    def setup(self, device: str):
+        super().setup(device)
+        if not _JINJA2_AVAILABLE:
+            raise ImportError(str(_JINJA2_AVAILABLE))
+        from jinja2 import Template
+
+        config_path = self.checkpoint_dir / "tokenizer_config.json"
+        if not config_path.is_file():
+            raise FileNotFoundError(f"Tokenizer config file not found at {config_path}")
+
+        with open(config_path, encoding="utf-8") as fp:
+            config = json.load(fp)
+            chat_template = config.get("chat_template", None)
+            if chat_template is None:
+                print("The tokenizer config does not contain chat_template, falling back to a default.")
+                chat_template = "{% for m in messages %}{{ m.role }}: {{ m.content }}\n{% endfor %}Assistant: "
+            self.chat_template = chat_template
+
+        self.template = Template(self.chat_template)
+
+    def decode_request(self, request: "ChatCompletionRequest") -> Any:
+        # Apply chat template to request messages
+        return self.template.render(messages=request.messages)
+
+    def predict(self, inputs: str, context: dict) -> Any:
+        # Extract parameters from context with fallback to instance attributes
+        temperature = context.get("temperature") or self.temperature
+        top_p = context.get("top_p", self.top_p) or self.top_p
+        max_new_tokens = context.get("max_completion_tokens") or self.max_new_tokens
+
+        # Run the model on the input and return the output.
+        yield from self.llm.generate(
+            inputs,
+            temperature=temperature,
+            top_k=self.top_k,
+            top_p=top_p,
+            max_new_tokens=max_new_tokens,
+            stream=True,
+        )
+
+
+def run_server(
+    checkpoint_dir: Path,
+    quantize: Optional[Literal["bnb.nf4", "bnb.nf4-dq", "bnb.fp4", "bnb.fp4-dq", "bnb.int8"]] = None,
+    precision: Optional[str] = None,
+    temperature: float = 0.8,
+    top_k: int = 50,
+    top_p: float = 1.0,
+    max_new_tokens: int = 50,
+    devices: int = 1,
+    accelerator: str = "auto",
+    port: int = 8000,
+    stream: bool = False,
+    openai_spec: bool = False,
+    access_token: Optional[str] = None,
+    api_path: Optional[str] = "/predict",
+) -> None:
+    """Serve a LitGPT model using LitServe.
+
+    Evaluate a model with the LM Evaluation Harness.
+
+    Arguments:
+        checkpoint_dir: The checkpoint directory to load the model from.
+        quantize: Whether to quantize the model and using which method:
+            - bnb.nf4, bnb.nf4-dq, bnb.fp4, bnb.fp4-dq: 4-bit quantization from bitsandbytes
+            - bnb.int8: 8-bit quantization from bitsandbytes
+            for more details, see https://github.com/Lightning-AI/litgpt/blob/main/tutorials/quantize.md
+        precision: Optional precision setting to instantiate the model weights in. By default, this will
+            automatically be inferred from the metadata in the given ``checkpoint_dir`` directory.
+        temperature: Temperature setting for the text generation. Value above 1 increase randomness.
+            Values below 1 decrease randomness.
+        top_k: The size of the pool of potential next tokens. Values larger than 1 result in more novel
+            generated text but can also lead to more incoherent texts.
+        top_p: If specified, it represents the cumulative probability threshold to consider in the sampling process.
+            In top-p sampling, the next token is sampled from the highest probability tokens
+            whose cumulative probability exceeds the threshold `top_p`. When specified,
+            it must be `0 <= top_p <= 1`. Here, `top_p=0` is equivalent
+            to sampling the most probable token, while `top_p=1` samples from the whole distribution.
+            It can be used in conjunction with `top_k` and `temperature` with the following order
+            of application:
+
+            1. `top_k` sampling
+            2. `temperature` scaling
+            3. `top_p` sampling
+
+            For more details, see https://arxiv.org/abs/1904.09751
+            or https://huyenchip.com/2024/01/16/sampling.html#top_p
+        max_new_tokens: The number of generation steps to take.
+        devices: How many devices/GPUs to use.
+        accelerator: The type of accelerator to use. For example, "auto", "cuda", "cpu", or "mps".
+            The "auto" setting (default) chooses a GPU if available, and otherwise uses a CPU.
+        port: The network port number on which the model is configured to be served.
+        stream: Whether to stream the responses.
+        openai_spec: Whether to use the OpenAISpec and enable OpenAI-compatible API endpoints. When True, the server will provide
+            `/v1/chat/completions` endpoints that work with the OpenAI SDK and other OpenAI-compatible clients,
+            making it easy to integrate with existing applications that use the OpenAI API.
+        access_token: Optional API token to access models with restrictions.
+        api_path: The custom API path for the endpoint (e.g., "/my_api/classify").
+    """
+    checkpoint_dir = auto_download_checkpoint(model_name=checkpoint_dir, access_token=access_token)
+    pprint(locals())
+
+    api_class = OpenAISpecLitAPI if openai_spec else StreamLitAPI if stream else SimpleLitAPI
+
+    server = LitServer(
+        api_class(
+            checkpoint_dir=checkpoint_dir,
+            quantize=quantize,
+            precision=precision,
+            temperature=temperature,
+            top_k=top_k,
+            top_p=top_p,
+            max_new_tokens=max_new_tokens,
+            devices=devices,
+            api_path=api_path,
+        ),
+        spec=OpenAISpec() if openai_spec else None,
+        accelerator=accelerator,
+        devices=1,
+        stream=stream,
+    )
+
+    server.run(port=port, generate_client_file=False)

litgpt/eval/evaluate.py

@@ -0,0 +1,155 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import json
+import os
+from pathlib import Path
+from pprint import pprint
+from typing import Optional, Union
+
+import torch
+
+from litgpt.scripts.convert_lit_checkpoint import convert_lit_checkpoint
+from litgpt.utils import auto_download_checkpoint, copy_config_files
+
+
+def prepare_results(results, save_filepath, print_results=True):
+    from lm_eval.utils import make_table
+
+    if print_results:
+        print(make_table(results))
+        if "groups" in results:
+            print(make_table(results, "groups"))
+
+    json_result = json.dumps(results, indent=2, ensure_ascii=False, default=str)
+    save_filepath.open("w", encoding="utf-8").write(json_result)
+
+
+def convert_and_evaluate(
+    checkpoint_dir: Path,
+    tasks: Optional[str] = None,
+    out_dir: Optional[Path] = None,
+    force_conversion: bool = False,
+    num_fewshot: Optional[int] = None,
+    batch_size: Union[int, str] = 1,
+    device: Optional[str] = None,
+    dtype: Optional[Union[str, torch.dtype]] = None,
+    limit: Optional[float] = None,
+    seed: int = 1234,
+    save_filepath: Optional[Path] = None,
+    access_token: Optional[str] = None,
+) -> None:
+    """Evaluate a model with the LM Evaluation Harness.
+
+    Arguments:
+        checkpoint_dir: Directory where the `lit_model.pth` and tokenizer files are located.
+        out_dir: Directory in which to save the converted checkpoints for evaluation.
+            Saves to `checkpoint_dir`/evaluate by default.
+        force_conversion: Set to `True` to reconvert the model and override
+            an existing model.pth from a previous evaluation call.
+        tasks: CSV of task names to evaluate. Example: "hellaswag,truthfulqa_mc2,mmlu"
+        num_fewshot: Number of examples in few-shot context.
+        batch_size: Batch size configuration as positive integer value (default: 1),
+            "auto", in the format 'auto:N', where 'auto:4' recomputes the batch size 4 times.
+        device: Device to use for evaluation, for example, "cuda" or "cuda:0".
+        limit: Limit on number of examples per task.
+        seed: Random seed.
+        save_filepath: The file where the results will be saved.
+            Saves to `out_dir/results.json` by default.
+        access_token: Optional API token to access models with restrictions.
+    """
+    if tasks is None:
+        from lm_eval.tasks import TaskManager
+
+        taskm = TaskManager()
+        print("\n".join(taskm.task_index.keys()))
+        print(
+            "\n\nTo evaluate multiple tasks, you can chain the task names "
+            "listed above via a comma-separated list."
+            "\nFor example: `--tasks 'hellaswag,truthfulqa_mc2,mmlu'`. "
+            "\nTo search for a specific task, use `litgpt evaluate list | grep task_name`."
+        )
+        return
+
+    checkpoint_dir = auto_download_checkpoint(model_name=checkpoint_dir, access_token=access_token)
+    pprint(locals())
+
+    if not (isinstance(batch_size, int) and batch_size > 0) and not (
+        isinstance(batch_size, str) and batch_size.startswith("auto")
+    ):
+        raise ValueError("batch_size must be a positive integer, 'auto', or in the format 'auto:N'.")
+
+    from lm_eval import evaluator
+
+    if device is None:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    if out_dir is None:
+        out_dir = checkpoint_dir / "evaluate"
+    else:
+        out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    save_filepath = out_dir / Path("results.json") if save_filepath is None else Path(save_filepath)
+
+    model_path = out_dir / "pytorch_model.bin"
+    if not model_path.exists() or force_conversion:
+        copy_config_files(source_dir=checkpoint_dir, out_dir=out_dir)
+        convert_lit_checkpoint(checkpoint_dir=checkpoint_dir, output_dir=out_dir)
+
+        # Hack: LitGPT's conversion doesn't save a pickle file that is compatible to be loaded with
+        # `torch.load(..., weights_only=True)`, which is a requirement in HFLM.
+        # So we're `torch.load`-ing and `torch.save`-ing it again to work around this.
+        state_dict = torch.load(out_dir / "model.pth")
+        torch.save(state_dict, model_path)
+        os.remove(out_dir / "model.pth")
+
+    from lm_eval.models.huggingface import HFLM
+
+    model = HFLM(pretrained=str(out_dir.resolve()), device=device, batch_size=batch_size, dtype=dtype)
+
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+    results = evaluator.simple_evaluate(
+        model=model,
+        tasks=tasks.split(","),
+        num_fewshot=num_fewshot,
+        batch_size=batch_size,
+        device=device,
+        limit=limit,
+        random_seed=seed,
+        numpy_random_seed=seed,
+        torch_random_seed=seed,
+        confirm_run_unsafe_code=True,
+    )
+
+    prepare_results(results, save_filepath)
+    output_data = {}
+
+    tasks_list = []
+    for task_name, metrics in results.get("results", {}).items():
+        for metric_key, value in metrics.items():
+            if metric_key.endswith("_stderr"):
+                continue
+            tasks_list.append({
+                "task": task_name,
+                "metric": metric_key.split(",")[0],
+                "value": value
+            })
+    output_data["tasks"] = tasks_list
+
+    if "groups" in results:
+        groups_list = []
+        for group_name, metrics in results["groups"].items():
+            for metric_key, value in metrics.items():
+                if metric_key.endswith("_stderr"):
+                    continue
+                groups_list.append({
+                    "group": group_name,
+                    "metric": metric_key.split(",")[0],
+                    "value": value
+                })
+        output_data["groups"] = groups_list
+
+    res_filepath = out_dir / Path("values.json")
+    with open(res_filepath, "w", encoding="utf-8") as f:
+        json.dump(output_data, f, ensure_ascii=False, indent=2)

litgpt/finetune/adapter.py

@@ -0,0 +1,491 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import dataclasses
+import math
+import os
+import time
+import warnings
+from pathlib import Path
+from pprint import pprint
+from typing import Dict, List, Literal, Optional, Tuple, Union
+
+import lightning as L
+import torch
+from lightning.fabric.plugins import BitsandbytesPrecision
+from lightning.fabric.strategies import FSDPStrategy
+from lightning.fabric.utilities import ThroughputMonitor
+from lightning_utilities.core.imports import RequirementCache
+from torch.utils.data import ConcatDataset, DataLoader
+from torchmetrics import RunningMean
+
+from litgpt.adapter import GPT, Block, Config, adapter_filter, mark_only_adapter_as_trainable
+from litgpt.args import EvalArgs, LogArgs, TrainArgs
+from litgpt.data import Alpaca, DataModule
+from litgpt.generate.base import generate
+from litgpt.prompts import save_prompt_style
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import (
+    CycleIterator,
+    auto_download_checkpoint,
+    check_nvlink_connectivity,
+    check_valid_checkpoint_dir,
+    choose_logger,
+    chunked_cross_entropy,
+    copy_config_files,
+    create_finetuning_performance_report,
+    get_default_supported_precision,
+    init_out_dir,
+    instantiate_bnb_optimizer,
+    instantiate_torch_optimizer,
+    load_checkpoint,
+    num_parameters,
+    parse_devices,
+    save_hyperparameters,
+    select_sft_generate_example,
+)
+
+
+def setup(
+    checkpoint_dir: Path,
+    out_dir: Path = Path("out/finetune/adapter"),
+    precision: Optional[str] = None,
+    quantize: Optional[Literal["bnb.nf4", "bnb.nf4-dq", "bnb.fp4", "bnb.fp4-dq", "bnb.int8-training"]] = None,
+    devices: Union[int, str] = 1,
+    num_nodes: int = 1,
+    data: Optional[DataModule] = None,
+    train: TrainArgs = TrainArgs(
+        save_interval=1000,
+        log_interval=1,
+        global_batch_size=16,
+        micro_batch_size=1,
+        lr_warmup_steps=100,
+        epochs=5,
+        max_seq_length=None,
+    ),
+    eval: EvalArgs = EvalArgs(interval=100, max_new_tokens=100, max_iters=100),
+    log: LogArgs = LogArgs(),
+    optimizer: Union[str, Dict] = "AdamW",
+    logger_name: Literal["wandb", "tensorboard", "csv", "mlflow"] = "csv",
+    seed: int = 1337,
+    access_token: Optional[str] = None,
+) -> None:
+    """Finetune a model using the Adapter method.
+
+    Arguments:
+        checkpoint_dir: The path to the base model's checkpoint directory to load for finetuning.
+        out_dir: Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+            /teamspace/jobs/<job-name>/share.
+        precision: The precision to use for finetuning. Possible choices: "bf16-true", "bf16-mixed", "32-true".
+        quantize: If set, quantize the model with this algorithm. See ``tutorials/quantize.md`` for more information.
+        devices: How many devices/GPUs to use.
+        num_nodes: How many nodes the code is being run on.
+        data: Data-related arguments. If not provided, the default is ``litgpt.data.Alpaca``.
+        train: Training-related arguments. See ``litgpt.args.TrainArgs`` for details.
+        eval: Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details.
+        optimizer: An optimizer name (such as "AdamW") or config.
+        logger_name: The name of the logger to send metrics to.
+        seed: The random seed to use for reproducibility.
+        access_token: Optional API token to access models with restrictions.
+    """
+    checkpoint_dir = auto_download_checkpoint(model_name=checkpoint_dir, access_token=access_token)
+    pprint(locals())
+    data = Alpaca() if data is None else data
+    devices = parse_devices(devices)
+    out_dir = init_out_dir(out_dir)
+
+    check_valid_checkpoint_dir(checkpoint_dir)
+    config = Config.from_file(checkpoint_dir / "model_config.yaml")
+
+    precision = precision or get_default_supported_precision(training=True)
+    logger = choose_logger(
+        logger_name,
+        out_dir,
+        name=f"finetune-{config.name}",
+        log_interval=train.log_interval,
+        log_args=dataclasses.asdict(log),
+    )
+
+    plugins = None
+    if quantize is not None and quantize.startswith("bnb."):
+        if "mixed" in precision:
+            raise ValueError("Quantization and mixed precision is not supported.")
+        if RequirementCache("bitsandbytes != 0.42.0"):
+            warnings.warn(
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
+            )
+        dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
+        plugins = BitsandbytesPrecision(quantize[4:], dtype)
+        precision = None
+
+    if devices * num_nodes > 1:
+        if quantize:
+            raise NotImplementedError(
+                "Quantization is currently not supported for multi-GPU training. Please set devices=1 and num_nodes=1"
+                " when using the --quantize flag."
+            )
+        strategy = FSDPStrategy(
+            auto_wrap_policy={Block},
+            activation_checkpointing_policy={Block},
+            state_dict_type="full",
+            limit_all_gathers=True,
+            cpu_offload=False,
+        )
+    else:
+        strategy = "auto"
+
+    fabric = L.Fabric(
+        devices=devices,
+        num_nodes=num_nodes,
+        strategy=strategy,
+        precision=precision,
+        loggers=logger,
+        plugins=plugins,
+    )
+
+    if torch.cuda.is_available() and devices > 1:
+        check_nvlink_connectivity(fabric)
+
+    fabric.launch(main, devices, seed, config, data, checkpoint_dir, out_dir, train, eval, optimizer, num_nodes)
+
+
+def main(
+    fabric: L.Fabric,
+    devices: int,
+    seed: int,
+    config: Config,
+    data: DataModule,
+    checkpoint_dir: Path,
+    out_dir: Path,
+    train: TrainArgs,
+    eval: EvalArgs,
+    optimizer: Union[str, Dict],
+    num_nodes: int = 1,
+) -> None:
+    validate_args(train, eval)
+
+    tokenizer = Tokenizer(checkpoint_dir)
+    train_dataloader, val_dataloader = get_dataloaders(fabric, data, tokenizer, train)
+    steps_per_epoch = len(train_dataloader) // train.gradient_accumulation_iters(devices, num_nodes)
+    lr_max_steps = min(train.epochs * steps_per_epoch, (train.max_steps or float("inf")))
+
+    fabric.seed_everything(seed)  # same seed for every process to init model (FSDP)
+
+    if fabric.global_rank == 0:
+        os.makedirs(out_dir, exist_ok=True)
+
+    checkpoint_path = checkpoint_dir / "lit_model.pth"
+    with fabric.init_module(empty_init=(fabric.world_size > 1)):
+        model = GPT(config)
+    mark_only_adapter_as_trainable(model)
+
+    fabric.print(f"Number of trainable parameters: {num_parameters(model, requires_grad=True):,}")
+    fabric.print(f"Number of non-trainable parameters: {num_parameters(model, requires_grad=False):,}")
+
+    model = fabric.setup_module(model)
+    if isinstance(fabric.strategy.precision, BitsandbytesPrecision):
+        optimizer = instantiate_bnb_optimizer(optimizer, model.parameters())
+
+        from bitsandbytes.nn import StableEmbedding
+
+        old_embedding = model.transformer.wte
+        model.transformer.wte = StableEmbedding(old_embedding.num_embeddings, old_embedding.embedding_dim)
+        with torch.no_grad():
+            model.transformer.wte.weight.copy_(old_embedding.weight)
+        model.transformer.wte = model.transformer.wte.to(
+            device=old_embedding.weight.device, dtype=old_embedding.weight.dtype
+        )
+    else:
+        optimizer = instantiate_torch_optimizer(optimizer, model.parameters())
+
+    optimizer = fabric.setup_optimizers(optimizer)
+    scheduler = get_lr_scheduler(optimizer, warmup_steps=train.lr_warmup_steps, max_steps=lr_max_steps)
+
+    # strict=False because missing keys due to Adapter weights not contained in state dict
+    load_checkpoint(fabric, model, checkpoint_path, strict=False)
+
+    train_time = time.perf_counter()
+    token_counts = fit(
+        fabric=fabric,
+        model=model,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        train_dataloader=train_dataloader,
+        val_dataloader=val_dataloader,
+        devices=devices,
+        num_nodes=num_nodes,
+        checkpoint_dir=checkpoint_dir,
+        out_dir=out_dir,
+        train=train,
+        eval=eval,
+        data=data,
+    )
+    training_time = time.perf_counter() - train_time
+    output = create_finetuning_performance_report(training_time, token_counts, fabric.device.type)
+    fabric.print(output)
+
+    # Final evaluation
+    if eval.final_validation:
+        val_loss = validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=len(val_dataloader)))
+        metrics = {"val_loss": val_loss, "val_ppl": math.exp(val_loss)}
+        fabric.log_dict(metrics)
+        fabric.print(f"Final evaluation | val loss: {val_loss.item():.3f} | val ppl: {math.exp(val_loss):.3f}")
+
+    # Save the final Adapter checkpoint at the end of training
+    save_path = out_dir / "final" / "lit_model.pth.adapter"
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    save_adapter_checkpoint(fabric, model, save_path)
+    if fabric.global_rank == 0:
+        # Copy checkpoint files from original checkpoint dir
+        copy_config_files(checkpoint_dir, save_path.parent)
+        save_hyperparameters(setup, save_path.parent)
+        save_prompt_style(data.prompt_style, save_path.parent)
+
+
+def fit(
+    fabric: L.Fabric,
+    model: GPT,
+    optimizer: torch.optim.Optimizer,
+    scheduler: torch.optim.lr_scheduler,
+    train_dataloader: DataLoader,
+    val_dataloader: DataLoader,
+    devices: int,
+    checkpoint_dir: Path,
+    out_dir: Path,
+    train: TrainArgs,
+    eval: EvalArgs,
+    data: DataModule,
+    num_nodes: int = 1,
+) -> None:
+    tokenizer = Tokenizer(checkpoint_dir)
+    longest_seq_length, longest_seq_ix = get_longest_seq_length(
+        ConcatDataset([train_dataloader.dataset, val_dataloader.dataset])
+    )
+    model.max_seq_length = min(longest_seq_length, train.max_seq_length or float("inf"))
+    fabric.print(
+        f"The longest sequence length in the train data is {longest_seq_length}, the model's maximum sequence length is"
+        f" {model.max_seq_length} and context length is {model.config.block_size}"
+    )
+
+    if eval.initial_validation:
+        val_loss = validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=len(val_dataloader)))
+        val_loss = f"{val_loss:.3f}"
+    else:
+        fabric.print("Verifying settings ...")
+        validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=2), verbose=False)  # sanity check
+        val_loss = "n/a"
+
+    train_iterator = CycleIterator(train_dataloader)
+    throughput = ThroughputMonitor(fabric, window_size=50)
+    running_loss = RunningMean(window=train.gradient_accumulation_iters(devices, num_nodes), sync_on_compute=False).to(
+        fabric.device
+    )
+    max_steps = train.max_steps or float("inf")
+    step_count = 0
+    iter_num = 0
+    total_lengths = 0
+    total_t0 = time.perf_counter()
+
+    token_counts = {
+        "raw_tokens": torch.tensor(0, device=fabric.device, dtype=torch.long),
+        "raw_tokens_plus_prompt_template": torch.tensor(0, device=fabric.device, dtype=torch.long),
+        "raw_tokens_plus_prompt_template_and_padding": torch.tensor(0, device=fabric.device, dtype=torch.long),
+    }
+
+    while step_count < max_steps:
+        iter_num += 1
+        iter_t0 = time.perf_counter()
+        batch = next(train_iterator)
+        if train_iterator.epoch >= train.epochs:
+            break
+        input_ids, targets = batch["input_ids"], batch["labels"]
+
+        is_accumulating = iter_num % train.gradient_accumulation_iters(devices, num_nodes) != 0
+        with fabric.no_backward_sync(model, enabled=is_accumulating):
+            logits = model(input_ids, lm_head_chunk_size=128)
+            # shift the targets such that output n predicts token n+1
+            logits[-1] = logits[-1][..., :-1, :]
+            loss = chunked_cross_entropy(logits, targets[..., 1:])
+            fabric.backward(loss / train.gradient_accumulation_iters(devices, num_nodes))
+
+        running_loss.update(loss.detach())
+
+        if not is_accumulating:
+            optimizer.step()
+            optimizer.zero_grad()
+            scheduler.step()
+            step_count += 1
+
+        token_counts["raw_tokens"] += batch["token_counts"]["raw"].sum().item()
+        token_counts["raw_tokens_plus_prompt_template"] += (
+            batch["token_counts"]["raw_plus_prompt_template"].sum().item()
+        )
+        token_counts["raw_tokens_plus_prompt_template_and_padding"] += input_ids.numel()
+
+        total_lengths += input_ids.numel()
+        if iter_num % train.log_interval == 0:
+            loss = running_loss.compute().item()  # expensive device-to-host synchronization
+            t1 = time.perf_counter()
+            throughput.update(
+                time=t1 - total_t0, batches=iter_num, samples=iter_num * train.micro_batch_size, lengths=total_lengths
+            )
+            throughput.compute_and_log(step=iter_num)
+            metrics = {
+                "loss": loss,
+                "iter": iter_num,
+                "step": step_count,
+                "epoch": train_iterator.epoch,
+                "iter_time": t1 - iter_t0,
+                "tokens": token_counts["raw_tokens_plus_prompt_template"],
+                "total_tokens": token_counts["raw_tokens_plus_prompt_template"] * fabric.world_size,
+                "learning_rate": scheduler.get_last_lr()[0],
+            }
+            if isinstance(val_loss, torch.Tensor):
+                val_loss = f"{val_loss:.3f}"
+            fabric.print(
+                f"Epoch {metrics['epoch'] + 1} | iter {metrics['iter']} step {metrics['step']} |"
+                f" loss train: {metrics['loss']:.3f},"
+                f" val: {val_loss} |"
+                f" iter time: {metrics['iter_time'] * 1000:.2f} ms"
+                f"{' (step)' if not is_accumulating else ''}"
+            )
+            fabric.log_dict(metrics, step=iter_num)
+
+        if not is_accumulating and step_count % eval.interval == 0:
+            t0 = time.perf_counter()
+            val_loss = validate(fabric, model, val_dataloader, eval)
+            generate_example(fabric, model, tokenizer, eval, data)
+            t1 = time.perf_counter() - t0
+
+            val_loss_tensor = val_loss.detach().clone().to(fabric.device)
+            val_time_tensor = torch.tensor(t1, device=fabric.device, dtype=torch.float32)
+
+            fabric.all_reduce(val_loss_tensor, reduce_op="mean")
+            fabric.all_reduce(val_time_tensor, reduce_op="mean")
+
+            fabric.print(
+                f"iter {iter_num}: val loss {val_loss_tensor.item():.4f}, val time: {val_time_tensor.item() * 1000:.2f} ms"
+            )
+            metrics = {"val_loss": val_loss_tensor, "val_ppl": math.exp(val_loss_tensor)}
+            fabric.log_dict(metrics, step=iter_num)
+            fabric.barrier()
+
+        if train.save_interval is not None and not is_accumulating and step_count % train.save_interval == 0:
+            checkpoint_file = out_dir / f"step-{step_count:06d}" / "lit_model.pth.adapter"
+            checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
+            save_adapter_checkpoint(fabric, model, checkpoint_file)
+            if fabric.global_rank == 0:
+                copy_config_files(checkpoint_dir, checkpoint_file.parent)
+                save_hyperparameters(setup, checkpoint_file.parent)
+                save_prompt_style(data.prompt_style, checkpoint_file.parent)
+
+    total_token_counts = {}
+    for key in token_counts:
+        total = fabric.all_reduce(token_counts[key], reduce_op="sum")
+        total_token_counts[key] = total.item()
+
+    return total_token_counts
+
+
+# FSDP has issues with `inference_mode`
+@torch.no_grad()
+def validate(
+    fabric: L.Fabric, model: GPT, val_dataloader: DataLoader, eval: EvalArgs, verbose: bool = True
+) -> torch.Tensor:
+    if verbose:
+        fabric.print("Validating ...")
+    model.eval()
+    losses = torch.zeros(min(len(val_dataloader), eval.max_iters))
+    for k, batch in enumerate(val_dataloader):
+        if k >= eval.max_iters:
+            break
+        input_ids, targets = batch["input_ids"], batch["labels"]
+        logits = model(input_ids)
+        losses[k] = chunked_cross_entropy(logits[..., :-1, :], targets[..., 1:], chunk_size=0)
+
+    val_loss = losses.mean()
+    model.train()
+    return val_loss
+
+
+# the adapter "kv cache" cannot be initialized under `inference_mode`
+@torch.no_grad()
+def generate_example(fabric: L.Fabric, model: GPT, tokenizer: Tokenizer, eval: EvalArgs, data: DataModule):
+    instruction = select_sft_generate_example(eval, data)
+    fabric.print(instruction)
+    prompt = data.prompt_style.apply(instruction)
+    encoded = tokenizer.encode(prompt, device=fabric.device)
+    model.eval()
+
+    with fabric.init_tensor():
+        # do not set `max_seq_length=max_returned_token` because memory is not a concern here
+        model.set_kv_cache(batch_size=1)
+
+    max_returned_tokens = len(encoded) + eval.max_new_tokens
+
+    if max_returned_tokens < model.max_seq_length:
+        with fabric.init_tensor():
+            # do not set `max_seq_length=max_returned_token` because memory is not a concern here
+            model.set_kv_cache(batch_size=1)
+        output = generate(
+            model, encoded, max_returned_tokens=max_returned_tokens, temperature=0.8, eos_id=tokenizer.eos_id
+        )
+        model.clear_kv_cache()
+        model.train()
+        output = tokenizer.decode(output)
+        fabric.print(f"{output}\n")
+    else:
+        print(
+            f"Length of encoded instruction ({len(encoded)}) and eval.max_new_tokens ({eval.max_new_tokens}) "
+            f"exceeds model.max_seq_length ({model.max_seq_length}) used for training. Skipping example generation for efficiency. "
+            f"The model's supported context size (post-training) is {model.config.block_size}."
+        )
+
+
+def get_lr_scheduler(optimizer, warmup_steps: int, max_steps: int):
+    # linear warmup followed by cosine annealing
+    scheduler1 = torch.optim.lr_scheduler.LambdaLR(optimizer, lambda step: step / warmup_steps)
+    scheduler2 = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=(max_steps - warmup_steps))
+    return torch.optim.lr_scheduler.SequentialLR(optimizer, [scheduler1, scheduler2], milestones=[warmup_steps])
+
+
+def get_dataloaders(
+    fabric: L.Fabric, data: DataModule, tokenizer: Tokenizer, train: TrainArgs
+) -> Tuple[DataLoader, DataLoader]:
+    data.connect(tokenizer=tokenizer, batch_size=train.micro_batch_size, max_seq_length=train.max_seq_length)
+    with fabric.rank_zero_first():
+        data.prepare_data()
+    data.setup()
+    train_dataloader = data.train_dataloader()
+    val_dataloader = data.val_dataloader()
+    train_dataloader, val_dataloader = fabric.setup_dataloaders(train_dataloader, val_dataloader)
+    return train_dataloader, val_dataloader
+
+
+def get_longest_seq_length(data: List[Dict]) -> Tuple[int, int]:
+    # find out the minimum max_seq_length required during fine-tuning (saves memory!)
+    lengths = [len(d["input_ids"]) for d in data]
+    longest_seq_length = max(lengths)
+    longest_seq_ix = lengths.index(longest_seq_length)
+    return longest_seq_length, longest_seq_ix
+
+
+def save_adapter_checkpoint(fabric: L.Fabric, model: torch.nn.Module, file_path: Path) -> None:
+    fabric.print(f"Saving adapter weights to {str(file_path)!r}")
+    fabric.save(file_path, {"model": model}, filter={"model": adapter_filter})
+
+
+def validate_args(train: TrainArgs, eval: EvalArgs) -> None:
+    issues = []
+    unsupported = [(train, ["max_tokens", "max_norm", "tie_embeddings", "lr_warmup_fraction"])]
+    for args, names in unsupported:
+        for name in names:
+            if getattr(args, name) is not None:
+                issues.append(f"{__file__} doesn't support the {name!r} argument. This is set in {args}")
+    required = [(train, ["epochs"]), (eval, ["max_new_tokens"])]
+    for args, names in required:
+        for name in names:
+            if getattr(args, name) is None:
+                issues.append(f"{__file__} requires the {name!r} argument. This is set in {args}")
+    if not train.epochs and not train.max_steps:
+        issues.append(f"{__file__} requires either epochs or max_steps to be set. This is set in {train}")
+    if issues:
+        raise ValueError("\n".join(issues))

litgpt/finetune/adapter_v2.py

@@ -0,0 +1,514 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import dataclasses
+import math
+import os
+import time
+import warnings
+from pathlib import Path
+from pprint import pprint
+from typing import Dict, List, Literal, Optional, Tuple, Union
+
+import lightning as L
+import torch
+from lightning.fabric.plugins import BitsandbytesPrecision
+from lightning.fabric.strategies import FSDPStrategy
+from lightning.fabric.utilities import ThroughputMonitor
+from lightning_utilities.core.imports import RequirementCache
+from torch.utils.data import ConcatDataset, DataLoader
+from torchmetrics import RunningMean
+
+from litgpt.adapter_v2 import GPT, Block, Config, adapter_filter, mark_only_adapter_v2_as_trainable
+from litgpt.args import EvalArgs, LogArgs, TrainArgs
+from litgpt.data import Alpaca, DataModule
+from litgpt.generate.base import generate
+from litgpt.prompts import save_prompt_style
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import (
+    CycleIterator,
+    auto_download_checkpoint,
+    check_nvlink_connectivity,
+    check_valid_checkpoint_dir,
+    choose_logger,
+    chunked_cross_entropy,
+    copy_config_files,
+    create_finetuning_performance_report,
+    get_default_supported_precision,
+    init_out_dir,
+    instantiate_bnb_optimizer,
+    instantiate_torch_optimizer,
+    load_checkpoint,
+    load_checkpoint_update,
+    num_parameters,
+    parse_devices,
+    save_hyperparameters,
+    select_sft_generate_example,
+)
+
+
+def setup(
+    checkpoint_dir: Path,
+    out_dir: Path = Path("out/finetune/adapter-v2"),
+    precision: Optional[str] = None,
+    quantize: Optional[Literal["bnb.nf4", "bnb.nf4-dq", "bnb.fp4", "bnb.fp4-dq", "bnb.int8-training"]] = None,
+    devices: Union[int, str] = 1,
+    num_nodes: int = 1,
+    resume: Optional[bool] = False,
+    data: Optional[DataModule] = None,
+    train: TrainArgs = TrainArgs(
+        save_interval=1000,
+        log_interval=1,
+        global_batch_size=16,
+        micro_batch_size=1,
+        lr_warmup_steps=100,
+        epochs=5,
+        max_seq_length=None,
+    ),
+    eval: EvalArgs = EvalArgs(interval=100, max_new_tokens=100, max_iters=100),
+    log: LogArgs = LogArgs(),
+    optimizer: Union[str, Dict] = "AdamW",
+    logger_name: Literal["wandb", "tensorboard", "csv", "mlflow"] = "csv",
+    seed: int = 1337,
+    access_token: Optional[str] = None,
+) -> None:
+    """Finetune a model using the Adapter V2 method.
+
+    Arguments:
+        checkpoint_dir: The path to the base model's checkpoint directory to load for finetuning.
+        out_dir: Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+            /teamspace/jobs/<job-name>/share.
+        precision: The precision to use for finetuning. Possible choices: "bf16-true", "bf16-mixed", "32-true".
+        quantize: If set, quantize the model with this algorithm. See ``tutorials/quantize.md`` for more information.
+        devices: How many devices/GPUs to use.
+        num_nodes: How many nodes the code is being run on.
+        data: Data-related arguments. If not provided, the default is ``litgpt.data.Alpaca``.
+        train: Training-related arguments. See ``litgpt.args.TrainArgs`` for details.
+        eval: Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details.
+        optimizer: An optimizer name (such as "AdamW") or config.
+        logger_name: The name of the logger to send metrics to.
+        seed: The random seed to use for reproducibility.
+        access_token: Optional API token to access models with restrictions.
+    """
+    checkpoint_dir = auto_download_checkpoint(model_name=checkpoint_dir, access_token=access_token)
+    pprint(locals())
+    data = Alpaca() if data is None else data
+    devices = parse_devices(devices)
+    out_dir = init_out_dir(out_dir)
+
+    check_valid_checkpoint_dir(checkpoint_dir)
+    config = Config.from_file(checkpoint_dir / "model_config.yaml")
+
+    precision = precision or get_default_supported_precision(training=True)
+    logger = choose_logger(
+        logger_name,
+        out_dir,
+        name=f"finetune-{config.name}",
+        log_interval=train.log_interval,
+        log_args=dataclasses.asdict(log),
+    )
+
+    plugins = None
+    if quantize is not None and quantize.startswith("bnb."):
+        if "mixed" in precision:
+            raise ValueError("Quantization and mixed precision is not supported.")
+        if RequirementCache("bitsandbytes != 0.42.0"):
+            warnings.warn(
+                "LitGPT only supports bitsandbytes v0.42.0. This may result in errors when using quantization."
+            )
+        dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
+        plugins = BitsandbytesPrecision(quantize[4:], dtype)
+        precision = None
+
+    if devices * num_nodes > 1:
+        if quantize:
+            raise NotImplementedError(
+                "Quantization is currently not supported for multi-GPU training. Please set devices=1 and num_nodes=1"
+                " when using the --quantize flag."
+            )
+        strategy = FSDPStrategy(
+            auto_wrap_policy={Block},
+            activation_checkpointing_policy={Block},
+            state_dict_type="full",
+            limit_all_gathers=True,
+            cpu_offload=False,
+        )
+    else:
+        strategy = "auto"
+
+    fabric = L.Fabric(
+        devices=devices,
+        num_nodes=num_nodes,
+        strategy=strategy,
+        precision=precision,
+        loggers=logger,
+        plugins=plugins,
+    )
+
+    if torch.cuda.is_available() and devices > 1:
+        check_nvlink_connectivity(fabric)
+
+    fabric.launch(main, devices, seed, config, data, resume, checkpoint_dir, out_dir, train, eval, optimizer, num_nodes)
+
+
+def main(
+    fabric: L.Fabric,
+    devices: int,
+    seed: int,
+    config: Config,
+    data: DataModule,
+    resume: bool,
+    checkpoint_dir: Path,
+    out_dir: Path,
+    train: TrainArgs,
+    eval: EvalArgs,
+    optimizer: Union[str, Dict],
+    num_nodes: int = 1,
+) -> None:
+    validate_args(train, eval)
+
+    tokenizer = Tokenizer(checkpoint_dir)
+    train_dataloader, val_dataloader = get_dataloaders(fabric, data, tokenizer, train)
+    steps_per_epoch = len(train_dataloader) // train.gradient_accumulation_iters(devices, num_nodes)
+    lr_max_steps = min(train.epochs * steps_per_epoch, (train.max_steps or float("inf")))
+
+    fabric.seed_everything(seed)  # same seed for every process to init model (FSDP)
+
+    if fabric.global_rank == 0:
+        os.makedirs(out_dir, exist_ok=True)
+
+    checkpoint_path = checkpoint_dir / "lit_model.pth"
+    with fabric.init_module(empty_init=(fabric.world_size > 1)):
+        model = GPT(config)
+    mark_only_adapter_v2_as_trainable(model)
+
+    fabric.print(f"Number of trainable parameters: {num_parameters(model, requires_grad=True):,}")
+    fabric.print(f"Number of non-trainable parameters: {num_parameters(model, requires_grad=False):,}")
+
+    model = fabric.setup_module(model)
+    if isinstance(fabric.strategy.precision, BitsandbytesPrecision):
+        optimizer = instantiate_bnb_optimizer(optimizer, model.parameters())
+
+        from bitsandbytes.nn import StableEmbedding
+
+        old_embedding = model.transformer.wte
+        model.transformer.wte = StableEmbedding(old_embedding.num_embeddings, old_embedding.embedding_dim)
+        with torch.no_grad():
+            model.transformer.wte.weight.copy_(old_embedding.weight)
+        model.transformer.wte = model.transformer.wte.to(
+            device=old_embedding.weight.device, dtype=old_embedding.weight.dtype
+        )
+    else:
+        optimizer = instantiate_torch_optimizer(optimizer, model.parameters())
+
+    optimizer = fabric.setup_optimizers(optimizer)
+    scheduler = get_lr_scheduler(optimizer, warmup_steps=train.lr_warmup_steps, max_steps=lr_max_steps)
+    if resume:
+        # Finding last trace of adapter training
+        try:
+            resume = max(out_dir.rglob("step-*/*.pth.adapter_v2"), key=(lambda p: int(p.parent.name.split("-")[1])))
+            fabric.print(f"Resuming training from {resume}")
+            load_checkpoint_update(fabric, resume, model, checkpoint_path, strict=False)
+            resume = True
+        except ValueError:
+            fabric.print("No previous adapter found. Finetune from start.")
+            resume = False
+            load_checkpoint(fabric, model, checkpoint_path, strict=False)
+    else:
+        # strict=False because missing keys due to Adapter weights not contained in state dict
+        load_checkpoint(fabric, model, checkpoint_path, strict=False)
+
+    mark_only_adapter_v2_as_trainable(model)
+
+    train_time = time.perf_counter()
+    token_counts = fit(
+        fabric=fabric,
+        model=model,
+        optimizer=optimizer,
+        scheduler=scheduler,
+        train_dataloader=train_dataloader,
+        val_dataloader=val_dataloader,
+        devices=devices,
+        resume=resume,
+        num_nodes=num_nodes,
+        checkpoint_dir=checkpoint_dir,
+        out_dir=out_dir,
+        train=train,
+        eval=eval,
+        data=data,
+    )
+    training_time = time.perf_counter() - train_time
+    output = create_finetuning_performance_report(training_time, token_counts, fabric.device.type)
+    fabric.print(output)
+
+    # Final evaluation
+    if eval.final_validation:
+        val_loss = validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=len(val_dataloader)))
+        metrics = {"val_loss": val_loss, "val_ppl": math.exp(val_loss)}
+        fabric.log_dict(metrics)
+        fabric.print(f"Final evaluation | val loss: {val_loss.item():.3f} | val ppl: {math.exp(val_loss):.3f}")
+
+    # Save the final Adapter checkpoint at the end of training
+    save_path = out_dir / "final" / "lit_model.pth.adapter_v2"
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    save_adapter_v2_checkpoint(fabric, model, save_path)
+    if fabric.global_rank == 0:
+        # Copy checkpoint files from original checkpoint dir
+        copy_config_files(checkpoint_dir, save_path.parent)
+        save_hyperparameters(setup, save_path.parent)
+        save_prompt_style(data.prompt_style, save_path.parent)
+
+
+def fit(
+    fabric: L.Fabric,
+    model: GPT,
+    optimizer: torch.optim.Optimizer,
+    scheduler: torch.optim.lr_scheduler,
+    train_dataloader: DataLoader,
+    val_dataloader: DataLoader,
+    devices: int,
+    resume: bool,
+    checkpoint_dir: Path,
+    out_dir: Path,
+    train: TrainArgs,
+    eval: EvalArgs,
+    data: DataModule,
+    num_nodes: int = 1,
+) -> None:
+    tokenizer = Tokenizer(checkpoint_dir)
+    longest_seq_length, longest_seq_ix = get_longest_seq_length(
+        ConcatDataset([train_dataloader.dataset, val_dataloader.dataset])
+    )
+    model.max_seq_length = min(longest_seq_length, train.max_seq_length or float("inf"))
+    fabric.print(
+        f"The longest sequence length in the train data is {longest_seq_length}, the model's maximum sequence length is"
+        f" {model.max_seq_length} and context length is {model.config.block_size}"
+    )
+
+    if eval.initial_validation:
+        val_loss = validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=len(val_dataloader)))
+        val_loss = f"{val_loss:.3f}"
+    else:
+        fabric.print("Verifying settings ...")
+        validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=2), verbose=False)  # sanity check
+        val_loss = "n/a"
+
+    train_iterator = CycleIterator(train_dataloader)
+    throughput = ThroughputMonitor(fabric, window_size=50)
+    running_loss = RunningMean(window=train.gradient_accumulation_iters(devices, num_nodes), sync_on_compute=False).to(
+        fabric.device
+    )
+    max_steps = train.max_steps or float("inf")
+    step_count = 0
+    iter_num = 0
+    total_lengths = 0
+    total_t0 = time.perf_counter()
+
+    token_counts = {
+        "raw_tokens": torch.tensor(0, device=fabric.device, dtype=torch.long),
+        "raw_tokens_plus_prompt_template": torch.tensor(0, device=fabric.device, dtype=torch.long),
+        "raw_tokens_plus_prompt_template_and_padding": torch.tensor(0, device=fabric.device, dtype=torch.long),
+    }
+
+    if not resume:
+        try:
+            iter_match = max(out_dir.rglob("step-*/*.pth.adapter_v2"), key=lambda p: int(p.parent.name.split("-")[1]))
+            step_count = int(iter_match.parent.name.split("-")[1]) if iter_match else 0
+        except ValueError:
+            step_count = 0
+
+    fabric.print(f"Starting at step count {step_count}")
+    while step_count < max_steps and train_iterator.epoch < train.epochs:
+        iter_num += 1
+        iter_t0 = time.perf_counter()
+        batch = next(train_iterator)
+        if train_iterator.epoch >= train.epochs:
+            break
+
+        input_ids, targets = batch["input_ids"], batch["labels"]
+
+        is_accumulating = iter_num % train.gradient_accumulation_iters(devices, num_nodes) != 0
+        with fabric.no_backward_sync(model, enabled=is_accumulating):
+            logits = model(input_ids, lm_head_chunk_size=128)
+            # shift the targets such that output n predicts token n+1
+            logits[-1] = logits[-1][..., :-1, :]
+            loss = chunked_cross_entropy(logits, targets[..., 1:])
+            fabric.backward(loss / train.gradient_accumulation_iters(devices, num_nodes))
+
+        running_loss.update(loss.detach())
+
+        if not is_accumulating:
+            optimizer.step()
+            optimizer.zero_grad()
+            scheduler.step()
+            step_count += 1
+
+        token_counts["raw_tokens"] += batch["token_counts"]["raw"].sum().item()
+        token_counts["raw_tokens_plus_prompt_template"] += (
+            batch["token_counts"]["raw_plus_prompt_template"].sum().item()
+        )
+        token_counts["raw_tokens_plus_prompt_template_and_padding"] += input_ids.numel()
+
+        total_lengths += input_ids.numel()
+        if iter_num % train.log_interval == 0:
+            loss = running_loss.compute().item()  # expensive device-to-host synchronization
+            t1 = time.perf_counter()
+            throughput.update(
+                time=t1 - total_t0, batches=iter_num, samples=iter_num * train.micro_batch_size, lengths=total_lengths
+            )
+            throughput.compute_and_log(step=iter_num)
+            metrics = {
+                "loss": loss,
+                "iter": iter_num,
+                "step": step_count,
+                "epoch": train_iterator.epoch,
+                "iter_time": t1 - iter_t0,
+                "tokens": token_counts["raw_tokens_plus_prompt_template"],
+                "total_tokens": token_counts["raw_tokens_plus_prompt_template"] * fabric.world_size,
+                "learning_rate": scheduler.get_last_lr()[0],
+            }
+            if isinstance(val_loss, torch.Tensor):
+                val_loss = f"{val_loss:.3f}"
+            fabric.print(
+                f"Epoch {metrics['epoch'] + 1} | iter {metrics['iter']} step {metrics['step']} |"
+                f" loss train: {metrics['loss']:.3f},"
+                f" val: {val_loss} |"
+                f" iter time: {metrics['iter_time'] * 1000:.2f} ms"
+                f"{' (step)' if not is_accumulating else ''}"
+            )
+            fabric.log_dict(metrics, step=iter_num)
+
+        if not is_accumulating and step_count % eval.interval == 0:
+            t0 = time.perf_counter()
+            val_loss = validate(fabric, model, val_dataloader, eval)
+            generate_example(fabric, model, tokenizer, eval, data)
+            t1 = time.perf_counter() - t0
+
+            val_loss_tensor = val_loss.detach().clone().to(fabric.device)
+            val_time_tensor = torch.tensor(t1, device=fabric.device, dtype=torch.float32)
+
+            fabric.all_reduce(val_loss_tensor, reduce_op="mean")
+            fabric.all_reduce(val_time_tensor, reduce_op="mean")
+
+            fabric.print(
+                f"iter {iter_num}: val loss {val_loss_tensor.item():.4f}, val time: {val_time_tensor.item() * 1000:.2f} ms"
+            )
+            metrics = {"val_loss": val_loss_tensor, "val_ppl": math.exp(val_loss_tensor)}
+            fabric.log_dict(metrics, step=iter_num)
+            fabric.barrier()
+
+        if train.save_interval is not None and not is_accumulating and step_count % train.save_interval == 0:
+            checkpoint_file = out_dir / f"step-{step_count:06d}" / "lit_model.pth.adapter_v2"
+            checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
+            save_adapter_v2_checkpoint(fabric, model, checkpoint_file)
+            if fabric.global_rank == 0:
+                copy_config_files(checkpoint_dir, checkpoint_file.parent)
+                save_hyperparameters(setup, checkpoint_file.parent)
+                save_prompt_style(data.prompt_style, checkpoint_file.parent)
+
+    total_token_counts = {}
+    for key in token_counts:
+        total = fabric.all_reduce(token_counts[key], reduce_op="sum")
+        total_token_counts[key] = total.item()
+
+    return total_token_counts
+
+
+# FSDP has issues with `inference_mode`
+@torch.no_grad()
+def validate(
+    fabric: L.Fabric, model: GPT, val_dataloader: DataLoader, eval: EvalArgs, verbose: bool = True
+) -> torch.Tensor:
+    if verbose:
+        fabric.print("Validating ...")
+    model.eval()
+    losses = torch.zeros(min(len(val_dataloader), eval.max_iters))
+    for k, batch in enumerate(val_dataloader):
+        if k >= eval.max_iters:
+            break
+        input_ids, targets = batch["input_ids"], batch["labels"]
+        logits = model(input_ids)
+        losses[k] = chunked_cross_entropy(logits[..., :-1, :], targets[..., 1:], chunk_size=0)
+
+    val_loss = losses.mean()
+    model.train()
+    return val_loss
+
+
+# the adapter "kv cache" cannot be initialized under `inference_mode`
+@torch.no_grad()
+def generate_example(fabric: L.Fabric, model: GPT, tokenizer: Tokenizer, eval: EvalArgs, data: DataModule):
+    instruction = select_sft_generate_example(eval, data)
+    fabric.print(instruction)
+    prompt = data.prompt_style.apply(instruction)
+    encoded = tokenizer.encode(prompt, device=fabric.device)
+    model.eval()
+
+    max_returned_tokens = len(encoded) + eval.max_new_tokens
+
+    if max_returned_tokens < model.max_seq_length:
+        with fabric.init_tensor():
+            # do not set `max_seq_length=max_returned_token` because memory is not a concern here
+            model.set_kv_cache(batch_size=1)
+        output = generate(
+            model, encoded, max_returned_tokens=max_returned_tokens, temperature=0.8, eos_id=tokenizer.eos_id
+        )
+        model.clear_kv_cache()
+        model.train()
+        output = tokenizer.decode(output)
+        fabric.print(f"{output}\n")
+    else:
+        print(
+            f"Length of encoded instruction ({len(encoded)}) and eval.max_new_tokens ({eval.max_new_tokens}) "
+            f"exceeds model.max_seq_length ({model.max_seq_length}) used for training. Skipping example generation for efficiency. "
+            f"The model's supported context size (post-training) is {model.config.block_size}."
+        )
+
+
+def get_lr_scheduler(optimizer, warmup_steps: int, max_steps: int):
+    # linear warmup followed by cosine annealing
+    scheduler1 = torch.optim.lr_scheduler.LambdaLR(optimizer, lambda step: step / warmup_steps)
+    scheduler2 = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=(max_steps - warmup_steps))
+    return torch.optim.lr_scheduler.SequentialLR(optimizer, [scheduler1, scheduler2], milestones=[warmup_steps])
+
+
+def get_dataloaders(
+    fabric: L.Fabric, data: DataModule, tokenizer: Tokenizer, train: TrainArgs
+) -> Tuple[DataLoader, DataLoader]:
+    data.connect(tokenizer=tokenizer, batch_size=train.micro_batch_size, max_seq_length=train.max_seq_length)
+    with fabric.rank_zero_first():
+        data.prepare_data()
+    data.setup()
+    train_dataloader = data.train_dataloader()
+    val_dataloader = data.val_dataloader()
+    train_dataloader, val_dataloader = fabric.setup_dataloaders(train_dataloader, val_dataloader)
+    return train_dataloader, val_dataloader
+
+
+def get_longest_seq_length(data: List[Dict]) -> Tuple[int, int]:
+    # find out the minimum max_seq_length required during fine-tuning (saves memory!)
+    lengths = [len(d["input_ids"]) for d in data]
+    longest_seq_length = max(lengths)
+    longest_seq_ix = lengths.index(longest_seq_length)
+    return longest_seq_length, longest_seq_ix
+
+
+def save_adapter_v2_checkpoint(fabric: L.Fabric, model: torch.nn.Module, file_path: Path) -> None:
+    fabric.print(f"Saving adapter v2 weights to {str(file_path)!r}")
+    fabric.save(file_path, {"model": model}, filter={"model": adapter_filter})
+
+
+def validate_args(train: TrainArgs, eval: EvalArgs) -> None:
+    issues = []
+    unsupported = [(train, ["max_tokens", "max_norm", "tie_embeddings", "lr_warmup_fraction"])]
+    for args, names in unsupported:
+        for name in names:
+            if getattr(args, name) is not None:
+                issues.append(f"{__file__} doesn't support the {name!r} argument. This is set in {args}")
+    required = [(train, ["epochs"]), (eval, ["max_new_tokens"])]
+    for args, names in required:
+        for name in names:
+            if getattr(args, name) is None:
+                issues.append(f"{__file__} requires the {name!r} argument. This is set in {args}")
+    if not train.epochs and not train.max_steps:
+        issues.append(f"{__file__} requires either epochs or max_steps to be set. This is set in {train}")
+    if issues:
+        raise ValueError("\n".join(issues))

litgpt/finetune/full.py

@@ -0,0 +1,457 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import dataclasses
+import math
+import os
+import time
+from pathlib import Path
+from pprint import pprint
+from typing import Dict, List, Literal, Optional, Tuple, Union
+
+import lightning as L
+import torch
+from lightning.fabric.strategies import FSDPStrategy
+from torch.utils.data import ConcatDataset, DataLoader
+from torchmetrics import RunningMean
+
+from litgpt.args import EvalArgs, LogArgs, TrainArgs
+from litgpt.data import Alpaca, DataModule
+from litgpt.generate.base import generate
+from litgpt.model import GPT, Block, Config
+from litgpt.prompts import save_prompt_style
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import (
+    CycleIterator,
+    auto_download_checkpoint,
+    check_nvlink_connectivity,
+    check_valid_checkpoint_dir,
+    choose_logger,
+    chunked_cross_entropy,
+    copy_config_files,
+    create_finetuning_performance_report,
+    find_resume_path,
+    get_default_supported_precision,
+    init_out_dir,
+    instantiate_torch_optimizer,
+    load_checkpoint,
+    num_parameters,
+    parse_devices,
+    save_hyperparameters,
+    select_sft_generate_example,
+)
+
+
+def setup(
+    checkpoint_dir: Path,
+    out_dir: Path = Path("out/finetune/full"),
+    precision: Optional[str] = None,
+    devices: Union[int, str] = 1,
+    num_nodes: int = 1,
+    resume: Union[bool, Literal["auto"], Path] = False,
+    data: Optional[DataModule] = None,
+    train: TrainArgs = TrainArgs(
+        save_interval=1000,
+        log_interval=1,
+        global_batch_size=16,
+        micro_batch_size=1,
+        lr_warmup_steps=100,
+        epochs=5,
+        max_seq_length=None,
+    ),
+    eval: EvalArgs = EvalArgs(interval=600, max_new_tokens=100, max_iters=100),
+    log: LogArgs = LogArgs(),
+    optimizer: Union[str, Dict] = "AdamW",
+    logger_name: Literal["wandb", "tensorboard", "csv", "mlflow"] = "csv",
+    seed: int = 1337,
+    access_token: Optional[str] = None,
+) -> None:
+    """Finetune a model.
+
+    Arguments:
+        checkpoint_dir: The path to the base model's checkpoint directory to load for finetuning.
+        out_dir: Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+            /teamspace/jobs/<job-name>/share.
+        precision: The precision to use for finetuning. Possible choices: "bf16-true", "bf16-mixed", "32-true".
+        devices: How many devices/GPUs to use
+        num_nodes: How many nodes the code is being run on.
+        resume: Path to a checkpoint directory to resume from in case training was interrupted, or ``True`` to resume
+            from the latest checkpoint in ``out_dir``. An error will be raised if no checkpoint is found. Passing
+            ``'auto'`` will resume from the latest checkpoint but not error if no checkpoint exists.
+        data: Data-related arguments. If not provided, the default is ``litgpt.data.Alpaca``.
+        train: Training-related arguments. See ``litgpt.args.TrainArgs`` for details.
+        eval: Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details.
+        optimizer: An optimizer name (such as "AdamW") or config.
+        logger_name: The name of the logger to send metrics to.
+        seed: The random seed to use for reproducibility.
+        access_token: Optional API token to access models with restrictions.
+    """
+    checkpoint_dir = auto_download_checkpoint(model_name=checkpoint_dir, access_token=access_token)
+    pprint(locals())
+    data = Alpaca() if data is None else data
+    devices = parse_devices(devices)
+    out_dir = init_out_dir(out_dir)
+
+    check_valid_checkpoint_dir(checkpoint_dir)
+    config = Config.from_file(checkpoint_dir / "model_config.yaml")
+
+    precision = precision or get_default_supported_precision(training=True)
+    logger = choose_logger(
+        logger_name,
+        out_dir,
+        name=f"finetune-{config.name}",
+        resume=bool(resume),
+        log_interval=train.log_interval,
+        log_args=dataclasses.asdict(log),
+    )
+
+    if devices * num_nodes > 1:
+        strategy = FSDPStrategy(
+            auto_wrap_policy={Block},
+            activation_checkpointing_policy={Block},
+            state_dict_type="full",
+            limit_all_gathers=True,
+            cpu_offload=False,
+        )
+    else:
+        strategy = "auto"
+
+    fabric = L.Fabric(devices=devices, num_nodes=num_nodes, strategy=strategy, precision=precision, loggers=logger)
+
+    if torch.cuda.is_available() and devices > 1:
+        check_nvlink_connectivity(fabric)
+
+    fabric.launch(main, devices, resume, seed, config, data, checkpoint_dir, out_dir, train, eval, optimizer, num_nodes)
+
+
+def main(
+    fabric: L.Fabric,
+    devices: int,
+    resume: Union[bool, Literal["auto"], Path],
+    seed: int,
+    config: Config,
+    data: DataModule,
+    checkpoint_dir: Path,
+    out_dir: Path,
+    train: TrainArgs,
+    eval: EvalArgs,
+    optimizer: Union[str, Dict],
+    num_nodes: int = 1,
+) -> None:
+    validate_args(train, eval)
+
+    tokenizer = Tokenizer(checkpoint_dir)
+    train_dataloader, val_dataloader = get_dataloaders(fabric, data, tokenizer, train)
+    steps_per_epoch = len(train_dataloader) // train.gradient_accumulation_iters(devices, num_nodes)
+    lr_max_steps = min(train.epochs * steps_per_epoch, (train.max_steps or float("inf")))
+
+    fabric.seed_everything(seed)  # same seed for every process to init model (FSDP)
+
+    if fabric.global_rank == 0:
+        os.makedirs(out_dir, exist_ok=True)
+
+    checkpoint_path = checkpoint_dir / "lit_model.pth"
+    with fabric.init_module(empty_init=(fabric.world_size > 1)):
+        model = GPT(config)
+
+    fabric.print(f"Number of trainable parameters: {num_parameters(model, requires_grad=True):,}")
+
+    model = fabric.setup(model)
+
+    optimizer = instantiate_torch_optimizer(optimizer, model.parameters())
+    optimizer = fabric.setup_optimizers(optimizer)
+    scheduler = get_lr_scheduler(optimizer, warmup_steps=train.lr_warmup_steps, max_steps=lr_max_steps)
+    state = {"model": model, "optimizer": optimizer, "scheduler": scheduler, "iter_num": 0, "step_count": 0}
+
+    resume = find_resume_path(resume, out_dir)
+    if resume:
+        fabric.print(f"Resuming training from {resume}")
+        fabric.load(resume, state)
+    else:
+        load_checkpoint(fabric, state["model"], checkpoint_path)
+
+    train_time = time.perf_counter()
+    token_counts = fit(
+        fabric=fabric,
+        state=state,
+        train_dataloader=train_dataloader,
+        val_dataloader=val_dataloader,
+        devices=devices,
+        num_nodes=num_nodes,
+        resume=resume,
+        checkpoint_dir=checkpoint_dir,
+        out_dir=out_dir,
+        train=train,
+        eval=eval,
+        data=data,
+    )
+    training_time = time.perf_counter() - train_time
+    output = create_finetuning_performance_report(training_time, token_counts, fabric.device.type)
+    fabric.print(output)
+
+    # Final evaluation
+    if eval.final_validation:
+        val_loss = validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=len(val_dataloader)))
+        metrics = {"val_loss": val_loss, "val_ppl": math.exp(val_loss)}
+        fabric.log_dict(metrics, step=state["iter_num"])
+        fabric.print(f"Final evaluation | val loss: {val_loss.item():.3f} | val ppl: {math.exp(val_loss):.3f}")
+
+    # Save the final checkpoint at the end of training
+    save_path = out_dir / "final" / "lit_model.pth"
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+    fabric.save(save_path, {"model": state["model"]})
+    if fabric.global_rank == 0:
+        # Copy checkpoint files from original checkpoint dir
+        copy_config_files(checkpoint_dir, save_path.parent)
+        save_hyperparameters(setup, save_path.parent)
+        save_prompt_style(data.prompt_style, save_path.parent)
+
+
+def fit(
+    fabric: L.Fabric,
+    state: Dict,
+    train_dataloader: DataLoader,
+    val_dataloader: DataLoader,
+    devices: int,
+    resume: Union[bool, Literal["auto"], Path],
+    checkpoint_dir: Path,
+    out_dir: Path,
+    train: TrainArgs,
+    eval: EvalArgs,
+    data: DataModule,
+    num_nodes: int = 1,
+) -> None:
+    model = state["model"]
+    optimizer = state["optimizer"]
+    scheduler = state["scheduler"]
+    tokenizer = Tokenizer(checkpoint_dir)
+    longest_seq_length, longest_seq_ix = get_longest_seq_length(
+        ConcatDataset([train_dataloader.dataset, val_dataloader.dataset])
+    )
+    model.max_seq_length = min(longest_seq_length, train.max_seq_length or float("inf"))
+    fabric.print(
+        f"The longest sequence length in the train data is {longest_seq_length}, the model's maximum sequence length is"
+        f" {model.max_seq_length} and context length is {model.config.block_size}"
+    )
+
+    token_counts = {
+        "raw_tokens": torch.tensor(0, device=fabric.device, dtype=torch.long),
+        "raw_tokens_plus_prompt_template": torch.tensor(0, device=fabric.device, dtype=torch.long),
+        "raw_tokens_plus_prompt_template_and_padding": torch.tensor(0, device=fabric.device, dtype=torch.long),
+    }
+
+    if eval.initial_validation:
+        val_loss = validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=len(val_dataloader)))
+        val_loss = f"{val_loss:.3f}"
+    else:
+        fabric.print("Verifying settings ...")
+        validate(fabric, model, val_dataloader, dataclasses.replace(eval, max_iters=2), verbose=False)  # sanity check
+        val_loss = "n/a"
+
+    initial_iter = state["iter_num"]
+    max_steps = train.max_steps or float("inf")
+    train_iterator = CycleIterator(train_dataloader)
+
+    # resume data loader state by fast-forwarding through all seen batches
+    if resume:
+        resume_t0 = time.perf_counter()
+        for resume_iter in range(initial_iter):
+            next(train_iterator)
+            if resume_iter % 1000 == 0:
+                fabric.print(f"Resuming dataset: {resume_iter} / {initial_iter}")
+        fabric.barrier()
+        fabric.print(
+            f"Resuming data loader finished. Took {time.perf_counter() - resume_t0:.1f} seconds to reach iteration"
+            f" {initial_iter}."
+        )
+
+    running_loss = RunningMean(window=train.gradient_accumulation_iters(devices, num_nodes), sync_on_compute=False).to(
+        fabric.device
+    )
+    fabric.barrier()
+
+    while state["step_count"] < max_steps:
+        state["iter_num"] += 1
+        iter_t0 = time.perf_counter()
+        batch = next(train_iterator)
+        if train_iterator.epoch >= train.epochs:
+            break
+        input_ids, targets = batch["input_ids"], batch["labels"]
+
+        is_accumulating = state["iter_num"] % train.gradient_accumulation_iters(devices, num_nodes) != 0
+        with fabric.no_backward_sync(model, enabled=is_accumulating):
+            logits = model(input_ids)
+            # shift the targets such that output n predicts token n+1
+            loss = chunked_cross_entropy(logits[..., :-1, :], targets[..., 1:])
+            fabric.backward(loss / train.gradient_accumulation_iters(devices, num_nodes))
+
+        running_loss.update(loss.detach())
+
+        if not is_accumulating:
+            optimizer.step()
+            optimizer.zero_grad()
+            scheduler.step()
+            state["step_count"] += 1
+
+        token_counts["raw_tokens"] += batch["token_counts"]["raw"].sum().item()
+        token_counts["raw_tokens_plus_prompt_template"] += (
+            batch["token_counts"]["raw_plus_prompt_template"].sum().item()
+        )
+        token_counts["raw_tokens_plus_prompt_template_and_padding"] += input_ids.numel()
+
+        if state["iter_num"] % train.log_interval == 0:
+            loss = running_loss.compute().item()  # expensive device-to-host synchronization
+            t1 = time.perf_counter()
+            metrics = {
+                "loss": loss,
+                "iter": state["iter_num"],
+                "step": state["step_count"],
+                "epoch": train_iterator.epoch,
+                "iter_time": t1 - iter_t0,
+                "tokens": token_counts["raw_tokens_plus_prompt_template"],
+                "total_tokens": token_counts["raw_tokens_plus_prompt_template"] * fabric.world_size,
+                "learning_rate": scheduler.get_last_lr()[0],
+            }
+            if isinstance(val_loss, torch.Tensor):
+                val_loss = f"{val_loss:.3f}"
+            fabric.print(
+                f"Epoch {metrics['epoch'] + 1} | iter {metrics['iter']} step {metrics['step']} |"
+                f" loss train: {metrics['loss']:.3f},"
+                f" val: {val_loss} |"
+                f" iter time: {metrics['iter_time'] * 1000:.2f} ms"
+                f"{' (step)' if not is_accumulating else ''}"
+            )
+            fabric.log_dict(metrics, step=state["iter_num"])
+
+        if not is_accumulating and state["step_count"] % eval.interval == 0:
+            t0 = time.perf_counter()
+            val_loss = validate(fabric, model, val_dataloader, eval)
+            generate_example(fabric, model, tokenizer, eval, data)
+            t1 = time.perf_counter() - t0
+
+            val_loss_tensor = val_loss.detach().clone().to(fabric.device)
+            val_time_tensor = torch.tensor(t1, device=fabric.device, dtype=torch.float32)
+
+            fabric.all_reduce(val_loss_tensor, reduce_op="mean")
+            fabric.all_reduce(val_time_tensor, reduce_op="mean")
+
+            fabric.print(
+                f"iter {state['iter_num']}: val loss {val_loss_tensor.item():.4f}, val time: {val_time_tensor.item() * 1000:.2f} ms"
+            )
+            metrics = {"val_loss": val_loss_tensor, "val_ppl": math.exp(val_loss_tensor)}
+            fabric.log_dict(metrics, step=state["iter_num"])
+            fabric.barrier()
+        if train.save_interval is not None and not is_accumulating and state["step_count"] % train.save_interval == 0:
+            checkpoint_file = out_dir / f"step-{state['step_count']:06d}" / "lit_model.pth"
+            checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
+            fabric.print(f"Saving checkpoint to {str(checkpoint_file.parent)!r}")
+            fabric.save(checkpoint_file, state)
+            if fabric.global_rank == 0:
+                copy_config_files(checkpoint_dir, checkpoint_file.parent)
+                save_hyperparameters(setup, checkpoint_file.parent)
+                save_prompt_style(data.prompt_style, checkpoint_file.parent)
+
+    total_token_counts = {}
+    for key in token_counts:
+        total = fabric.all_reduce(token_counts[key], reduce_op="sum")
+        total_token_counts[key] = total.item()
+
+    return total_token_counts
+
+
+# FSDP has issues with `inference_mode`
+@torch.no_grad()
+def validate(
+    fabric: L.Fabric, model: GPT, val_dataloader: DataLoader, eval: EvalArgs, verbose: bool = True
+) -> torch.Tensor:
+    if verbose:
+        fabric.print("Validating ...")
+    model.eval()
+    losses = torch.zeros(min(len(val_dataloader), eval.max_iters))
+    for k, batch in enumerate(val_dataloader):
+        if k >= eval.max_iters:
+            break
+        input_ids, targets = batch["input_ids"], batch["labels"]
+        logits = model(input_ids)
+        losses[k] = chunked_cross_entropy(logits[..., :-1, :], targets[..., 1:], chunk_size=0)
+
+    val_loss = losses.mean()
+    model.train()
+    return val_loss
+
+
+@torch.no_grad()
+def generate_example(fabric: L.Fabric, model: GPT, tokenizer: Tokenizer, eval: EvalArgs, data: DataModule):
+    instruction = select_sft_generate_example(eval, data)
+    fabric.print(instruction)
+    prompt = data.prompt_style.apply(instruction)
+    encoded = tokenizer.encode(prompt, device=fabric.device)
+    model.eval()
+
+    with fabric.init_tensor():
+        # do not set `max_seq_length=max_returned_token` because memory is not a concern here
+        model.set_kv_cache(batch_size=1)
+
+    max_returned_tokens = len(encoded) + eval.max_new_tokens
+
+    if max_returned_tokens < model.max_seq_length:
+        with fabric.init_tensor():
+            # do not set `max_seq_length=max_returned_token` because memory is not a concern here
+            model.set_kv_cache(batch_size=1)
+        output = generate(
+            model, encoded, max_returned_tokens=max_returned_tokens, temperature=0.8, eos_id=tokenizer.eos_id
+        )
+        model.clear_kv_cache()
+        model.train()
+        output = tokenizer.decode(output)
+        fabric.print(f"{output}\n")
+    else:
+        print(
+            f"Length of encoded instruction ({len(encoded)}) and eval.max_new_tokens ({eval.max_new_tokens}) "
+            f"exceeds model.max_seq_length ({model.max_seq_length}) used for training. Skipping example generation for efficiency. "
+            f"The model's supported context size (post-training) is {model.config.block_size}."
+        )
+
+
+def get_lr_scheduler(optimizer, warmup_steps: int, max_steps: int):
+    # linear warmup followed by cosine annealing
+    scheduler1 = torch.optim.lr_scheduler.LambdaLR(optimizer, lambda step: step / warmup_steps)
+    scheduler2 = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=(max_steps - warmup_steps))
+    return torch.optim.lr_scheduler.SequentialLR(optimizer, [scheduler1, scheduler2], milestones=[warmup_steps])
+
+
+def get_dataloaders(
+    fabric: L.Fabric, data: DataModule, tokenizer: Tokenizer, train: TrainArgs
+) -> Tuple[DataLoader, DataLoader]:
+    data.connect(tokenizer=tokenizer, batch_size=train.micro_batch_size, max_seq_length=train.max_seq_length)
+    with fabric.rank_zero_first():
+        data.prepare_data()
+    data.setup()
+    train_dataloader = data.train_dataloader()
+    val_dataloader = data.val_dataloader()
+    train_dataloader, val_dataloader = fabric.setup_dataloaders(train_dataloader, val_dataloader)
+    return train_dataloader, val_dataloader
+
+
+def get_longest_seq_length(data: List[Dict]) -> Tuple[int, int]:
+    # find out the minimum max_seq_length required during fine-tuning (saves memory!)
+    lengths = [len(d["input_ids"]) for d in data]
+    longest_seq_length = max(lengths)
+    longest_seq_ix = lengths.index(longest_seq_length)
+    return longest_seq_length, longest_seq_ix
+
+
+def validate_args(train: TrainArgs, eval: EvalArgs) -> None:
+    issues = []
+    unsupported = [(train, ["max_tokens", "max_norm", "tie_embeddings", "lr_warmup_fraction"])]
+    for args, names in unsupported:
+        for name in names:
+            if getattr(args, name) is not None:
+                issues.append(f"{__file__} doesn't support the {name!r} argument. This is set in {args}")
+    required = [(train, ["epochs"]), (eval, ["max_new_tokens"])]
+    for args, names in required:
+        for name in names:
+            if getattr(args, name) is None:
+                issues.append(f"{__file__} requires the {name!r} argument. This is set in {args}")
+    if not train.epochs and not train.max_steps:
+        issues.append(f"{__file__} requires either epochs or max_steps to be set. This is set in {train}")
+    if issues:
+        raise ValueError("\n".join(issues))