Add files using upload-large-folder tool

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+out/eval/tinyllama_benches/2407_full/results.json filter=lfs diff=lfs merge=lfs -text
+out/eval/tinyllama_benches/2408_full/results.json filter=lfs diff=lfs merge=lfs -text

.github/workflows/mkdocs-deploy.yml

@@ -0,0 +1,32 @@
+name: Deploy MkDocs
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-24.04
+    steps:
+      # Step 1: Checkout the repository
+      - uses: actions/checkout@v4
+
+      # Step 2: Set up Python
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+          cache: "pip"
+
+      # Step 3: Install MkDocs and dependencies
+      - run: pip install mkdocs mkdocs-material mkdocs-pagetree-plugin
+      # Step 4: Deploy to GitHub Pages
+      - run: |
+          mkdir -p gh-pages/docs
+          cp -r tutorials/* gh-pages/docs
+          cd gh-pages
+          mv docs/mkdocs.yml mkdocs.yml
+          echo "{{ pagetree }}" > docs/index.md
+          mkdocs gh-deploy --force

.github/workflows/publish-pkg.yml

@@ -0,0 +1,41 @@
+# To create a release, create a tag and push it to GitHub:
+#git tag -a "v0.0.1-beta" -m "beta version testing"
+#git push --tags
+# https://dev.to/iamtekson/publish-package-to-pypi-and-release-new-version-using-github-actions-108k
+name: Publish LitGPT to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+jobs:
+  build-n-publish:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/litgpt
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+          cache: "pip"
+
+      - name: Build source and wheel distributions
+        run: |
+          python -m pip install --upgrade build twine
+          pip install importlib_metadata==7.2.1
+          python -m build
+          twine check --strict dist/*
+      - name: Publish distribution to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}

config_hub/eval/arxivcl.yaml

@@ -0,0 +1,117 @@
+# The name of the model to pretrain. Choose from names in ``litgpt.config``. Mutually exclusive with
+# ``model_config``. (type: Optional[str], default: null)
+model_name: tiny-llama-1.1b
+
+# A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+# ``model_config``. (type: Optional[Config], default: null)
+model_config:
+
+# Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+# /teamspace/jobs/<job-name>/share. (type: <class 'Path'>, default: out/pretrain)
+out_dir: out/pretrain/2407
+
+# The precision to use for pretraining. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-mixed
+
+# Optional path to a checkpoint directory to initialize the model from.
+# Useful for continued pretraining. Mutually exclusive with ``resume``. (type: Optional[Path], default: null)
+initial_checkpoint_dir: checkpoints/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T
+
+# 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.
+# (type: Union[bool, Literal["auto"], Path], default: False)
+resume: false
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+data: Arxiv
+
+# Data-Dir
+data_dir:
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 100
+
+  # Number of iterations between logging calls (type: int, default: 1)
+  log_interval: 1
+
+  # Number of samples between optimizer steps across data-parallel ranks (type: int, default: 512)
+  global_batch_size: 512
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 4
+
+  # Number of iterations with learning rate warmup active (type: int, default: 2000)
+  lr_warmup_steps: 20
+
+  # Number of epochs to train on (type: Optional[int], default: null)
+  epochs:
+
+  # Total number of tokens to train on (type: Optional[int], default: 3000000000000)
+  max_tokens: 209715200
+
+  # Limits the number of optimizer steps to run. (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples. Off by default (type: Optional[int], default: null)
+  max_seq_length: 2048
+
+  # Whether to tie the embedding weights with the language modeling head weights. (type: Optional[bool], default: False)
+  tie_embeddings:
+
+  #   (type: Optional[float], default: 1.0)
+  max_norm: 1.0
+
+  #   (type: float, default: 4e-05)
+  min_lr: 4.0e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+  # Number of optimizer steps between evaluation calls (type: int, default: 1000)
+  interval: 50
+
+  # Number of tokens to generate (type: Optional[int], default: null)
+  max_new_tokens:
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 200
+
+  # Whether to evaluate on the validation set at the beginning of the training
+  initial_validation: false
+
+  # Whether to evaluate on the validation set at the end the training
+  final_validation: true
+
+# Optimizer-related arguments
+optimizer:
+  class_path: torch.optim.AdamW
+
+  init_args:
+    #   (type: float, default: 0.001)
+    lr: 4e-4
+
+    #   (type: float, default: 0.01)
+    weight_decay: 0.1
+
+    #   (type: tuple, default: (0.9,0.999))
+    betas:
+      - 0.9
+      - 0.95
+
+# How many devices/GPUs to use. Uses all GPUs by default. (type: Union[int, str], default: auto)
+devices: auto
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+# module require this. (type: Optional[Path], default: null)
+tokenizer_dir: checkpoints/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: tensorboard)
+logger_name: tensorboard
+
+# The random seed to use for reproducibility. (type: int, default: 42)
+seed: 42

config_hub/eval/openllama_cl_ppl.yaml

@@ -0,0 +1,123 @@
+# The name of the model to pretrain. Choose from names in ``litgpt.config``. Mutually exclusive with
+# ``model_config``. (type: Optional[str], default: null)
+model_name: open_llama_3b
+
+# A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+# ``model_config``. (type: Optional[Config], default: null)
+model_config:
+
+# Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+# /teamspace/jobs/<job-name>/share. (type: <class 'Path'>, default: out/pretrain)
+out_dir: out/pretrain/2407
+
+# The precision to use for pretraining. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-mixed
+
+# Optional path to a checkpoint directory to initialize the model from.
+# Useful for continued pretraining. Mutually exclusive with ``resume``. (type: Optional[Path], default: null)
+initial_checkpoint_dir: checkpoints/openlm-research/open_llama_3b
+
+# 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.
+# (type: Union[bool, Literal["auto"], Path], default: False)
+resume: false
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+data:
+  class_path: litgpt.data.Arxiv
+  init_args:
+    ppl: true
+    data_path:
+
+# Data-Dir
+data_dir: litgpt/data/arxiv_openllama_tokenized
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 100
+
+  # Number of iterations between logging calls (type: int, default: 1)
+  log_interval: 1
+
+  # Number of samples between optimizer steps across data-parallel ranks (type: int, default: 512)
+  global_batch_size: 512
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 4
+
+  # Number of iterations with learning rate warmup active (type: int, default: 2000)
+  lr_warmup_steps: 20
+
+  # Number of epochs to train on (type: Optional[int], default: null)
+  epochs:
+
+  # Total number of tokens to train on (type: Optional[int], default: 3000000000000)
+  max_tokens: 209715200
+
+  # Limits the number of optimizer steps to run. (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples. Off by default (type: Optional[int], default: null)
+  max_seq_length: 2048
+
+  # Whether to tie the embedding weights with the language modeling head weights. (type: Optional[bool], default: False)
+  tie_embeddings:
+
+  #   (type: Optional[float], default: 1.0)
+  max_norm: 1.0
+
+  #   (type: float, default: 4e-05)
+  min_lr: 4.0e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+  # Number of optimizer steps between evaluation calls (type: int, default: 1000)
+  interval: 50
+
+  # Number of tokens to generate (type: Optional[int], default: null)
+  max_new_tokens:
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 200
+
+  # Whether to evaluate on the validation set at the beginning of the training
+  initial_validation: false
+
+  # Whether to evaluate on the validation set at the end the training
+  final_validation: true
+
+# Optimizer-related arguments
+optimizer:
+  class_path: torch.optim.AdamW
+
+  init_args:
+    #   (type: float, default: 0.001)
+    lr: 4e-4
+
+    #   (type: float, default: 0.01)
+    weight_decay: 0.1
+
+    #   (type: tuple, default: (0.9,0.999))
+    betas:
+      - 0.9
+      - 0.95
+
+# How many devices/GPUs to use. Uses all GPUs by default. (type: Union[int, str], default: auto)
+devices: auto
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+# module require this. (type: Optional[Path], default: null)
+tokenizer_dir: checkpoints/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: tensorboard)
+logger_name: tensorboard
+
+# The random seed to use for reproducibility. (type: int, default: 42)
+seed: 42
+
+multi_month: true

config_hub/eval/qwen2_cl_ppl.yaml

@@ -0,0 +1,123 @@
+# The name of the model to pretrain. Choose from names in ``litgpt.config``. Mutually exclusive with
+# ``model_config``. (type: Optional[str], default: null)
+model_name: Qwen2-7B
+
+# A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+# ``model_config``. (type: Optional[Config], default: null)
+model_config:
+
+# Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+# /teamspace/jobs/<job-name>/share. (type: <class 'Path'>, default: out/pretrain)
+out_dir:
+
+# The precision to use for pretraining. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-true
+
+# Optional path to a checkpoint directory to initialize the model from.
+# Useful for continued pretraining. Mutually exclusive with ``resume``. (type: Optional[Path], default: null)
+initial_checkpoint_dir: checkpoints/Qwen/Qwen2-7B
+
+# 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.
+# (type: Union[bool, Literal["auto"], Path], default: False)
+resume: false
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+data:
+  class_path: litgpt.data.Arxiv
+  init_args:
+    ppl: true
+    data_path:
+
+data_dir: litgpt/data/arxiv_qwen2_tokenized
+
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 9999
+
+  # Number of iterations between logging calls (type: int, default: 1)
+  log_interval: 1
+
+  # Number of samples between optimizer steps across data-parallel ranks (type: int, default: 512)
+  global_batch_size: 128
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 1
+
+  # Number of iterations with learning rate warmup active (type: int, default: 2000)
+  lr_warmup_steps: 0
+
+  # Number of epochs to train on (type: Optional[int], default: null)
+  epochs:
+
+  # Total number of tokens to train on (type: Optional[int], default: 3000000000000)
+  max_tokens: 3000000000000
+
+  # Limits the number of optimizer steps to run. (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples. Off by default (type: Optional[int], default: null)
+  max_seq_length: 8192
+
+  # Whether to tie the embedding weights with the language modeling head weights. (type: Optional[bool], default: False)
+  tie_embeddings:
+
+  #   (type: Optional[float], default: 1.0)
+  max_norm: 1.0
+
+  #   (type: float, default: 4e-05)
+  min_lr: 2.0e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+  # Number of optimizer steps between evaluation calls (type: int, default: 1000)
+  interval: 1000
+
+  # Number of tokens to generate (type: Optional[int], default: null)
+  max_new_tokens:
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 200
+
+  # Whether to evaluate on the validation set at the beginning of the training
+  initial_validation: false
+
+  # Whether to evaluate on the validation set at the end the training
+  final_validation: true
+
+# Optimizer-related arguments
+optimizer:
+  class_path: torch.optim.AdamW
+
+  init_args:
+    #   (type: float, default: 0.001)
+    lr: 2.0e-05
+
+    #   (type: float, default: 0.01)
+    weight_decay: 0.1
+
+    #   (type: tuple, default: (0.9,0.999))
+    betas:
+      - 0.9
+      - 0.95
+
+# How many devices/GPUs to use. Uses all GPUs by default. (type: Union[int, str], default: auto)
+devices: auto
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+# module require this. (type: Optional[Path], default: null)
+tokenizer_dir: checkpoints/Qwen/Qwen2-7B
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: tensorboard)
+logger_name: tensorboard
+
+# The random seed to use for reproducibility. (type: int, default: 42)
+seed: 42
+
+multi_month: true

config_hub/eval/tinyllama_cl.yaml

@@ -0,0 +1,117 @@
+# The name of the model to pretrain. Choose from names in ``litgpt.config``. Mutually exclusive with
+# ``model_config``. (type: Optional[str], default: null)
+model_name: tiny-llama-1.1b
+
+# A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+# ``model_config``. (type: Optional[Config], default: null)
+model_config:
+
+# Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+# /teamspace/jobs/<job-name>/share. (type: <class 'Path'>, default: out/pretrain)
+out_dir: out/pretrain/2407
+
+# The precision to use for pretraining. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-mixed
+
+# Optional path to a checkpoint directory to initialize the model from.
+# Useful for continued pretraining. Mutually exclusive with ``resume``. (type: Optional[Path], default: null)
+initial_checkpoint_dir: checkpoints/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T
+
+# 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.
+# (type: Union[bool, Literal["auto"], Path], default: False)
+resume: false
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+data: Arxiv
+
+# Data-Dir
+data_dir:
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 100
+
+  # Number of iterations between logging calls (type: int, default: 1)
+  log_interval: 1
+
+  # Number of samples between optimizer steps across data-parallel ranks (type: int, default: 512)
+  global_batch_size: 512
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 4
+
+  # Number of iterations with learning rate warmup active (type: int, default: 2000)
+  lr_warmup_steps: 20
+
+  # Number of epochs to train on (type: Optional[int], default: null)
+  epochs:
+
+  # Total number of tokens to train on (type: Optional[int], default: 3000000000000)
+  max_tokens: 209715200
+
+  # Limits the number of optimizer steps to run. (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples. Off by default (type: Optional[int], default: null)
+  max_seq_length: 2048
+
+  # Whether to tie the embedding weights with the language modeling head weights. (type: Optional[bool], default: False)
+  tie_embeddings:
+
+  #   (type: Optional[float], default: 1.0)
+  max_norm: 1.0
+
+  #   (type: float, default: 4e-05)
+  min_lr: 4.0e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+  # Number of optimizer steps between evaluation calls (type: int, default: 1000)
+  interval: 50
+
+  # Number of tokens to generate (type: Optional[int], default: null)
+  max_new_tokens:
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 200
+
+  # Whether to evaluate on the validation set at the beginning of the training
+  initial_validation: false
+
+  # Whether to evaluate on the validation set at the end the training
+  final_validation: true
+
+# Optimizer-related arguments
+optimizer:
+  class_path: torch.optim.AdamW
+
+  init_args:
+    #   (type: float, default: 0.001)
+    lr: 4e-4
+
+    #   (type: float, default: 0.01)
+    weight_decay: 0.1
+
+    #   (type: tuple, default: (0.9,0.999))
+    betas:
+      - 0.9
+      - 0.95
+
+# How many devices/GPUs to use. Uses all GPUs by default. (type: Union[int, str], default: auto)
+devices: auto
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+# module require this. (type: Optional[Path], default: null)
+tokenizer_dir: checkpoints/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: tensorboard)
+logger_name: tensorboard
+
+# The random seed to use for reproducibility. (type: int, default: 42)
+seed: 42

config_hub/eval/tinyllama_cl_ppl.yaml

@@ -0,0 +1,123 @@
+# The name of the model to pretrain. Choose from names in ``litgpt.config``. Mutually exclusive with
+# ``model_config``. (type: Optional[str], default: null)
+model_name: tiny-llama-1.1b
+
+# A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+# ``model_config``. (type: Optional[Config], default: null)
+model_config:
+
+# Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+# /teamspace/jobs/<job-name>/share. (type: <class 'Path'>, default: out/pretrain)
+out_dir: out/pretrain/2407
+
+# The precision to use for pretraining. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-mixed
+
+# Optional path to a checkpoint directory to initialize the model from.
+# Useful for continued pretraining. Mutually exclusive with ``resume``. (type: Optional[Path], default: null)
+initial_checkpoint_dir: checkpoints/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T
+
+# 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.
+# (type: Union[bool, Literal["auto"], Path], default: False)
+resume: false
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+data:
+  class_path: litgpt.data.Arxiv
+  init_args:
+    ppl: true
+    data_path:
+
+# Data-Dir
+data_dir:
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 100
+
+  # Number of iterations between logging calls (type: int, default: 1)
+  log_interval: 1
+
+  # Number of samples between optimizer steps across data-parallel ranks (type: int, default: 512)
+  global_batch_size: 512
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 4
+
+  # Number of iterations with learning rate warmup active (type: int, default: 2000)
+  lr_warmup_steps: 20
+
+  # Number of epochs to train on (type: Optional[int], default: null)
+  epochs:
+
+  # Total number of tokens to train on (type: Optional[int], default: 3000000000000)
+  max_tokens: 209715200
+
+  # Limits the number of optimizer steps to run. (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples. Off by default (type: Optional[int], default: null)
+  max_seq_length: 2048
+
+  # Whether to tie the embedding weights with the language modeling head weights. (type: Optional[bool], default: False)
+  tie_embeddings:
+
+  #   (type: Optional[float], default: 1.0)
+  max_norm: 1.0
+
+  #   (type: float, default: 4e-05)
+  min_lr: 4.0e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+  # Number of optimizer steps between evaluation calls (type: int, default: 1000)
+  interval: 50
+
+  # Number of tokens to generate (type: Optional[int], default: null)
+  max_new_tokens:
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 200
+
+  # Whether to evaluate on the validation set at the beginning of the training
+  initial_validation: false
+
+  # Whether to evaluate on the validation set at the end the training
+  final_validation: true
+
+# Optimizer-related arguments
+optimizer:
+  class_path: torch.optim.AdamW
+
+  init_args:
+    #   (type: float, default: 0.001)
+    lr: 4e-4
+
+    #   (type: float, default: 0.01)
+    weight_decay: 0.1
+
+    #   (type: tuple, default: (0.9,0.999))
+    betas:
+      - 0.9
+      - 0.95
+
+# How many devices/GPUs to use. Uses all GPUs by default. (type: Union[int, str], default: auto)
+devices: auto
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+# module require this. (type: Optional[Path], default: null)
+tokenizer_dir: checkpoints/TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: tensorboard)
+logger_name: tensorboard
+
+# The random seed to use for reproducibility. (type: int, default: 42)
+seed: 42
+
+multi_month: true

extensions/thunder/strategies/__init__.py

@@ -0,0 +1,2 @@
+from .thunder_ddp import ThunderDDPStrategy  # noqa: F401
+from .thunder_fsdp import ThunderFSDPStrategy  # noqa: F401

extensions/thunder/strategies/thunder_ddp.py

@@ -0,0 +1,258 @@
+"""Fabric Strategy to support Thunder DDP: To be upstreamed into Fabric eventually."""
+
+from contextlib import nullcontext
+from datetime import timedelta
+from typing import TYPE_CHECKING, Any, ContextManager, Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.distributed
+from lightning.fabric.accelerators.accelerator import Accelerator
+from lightning.fabric.plugins.collectives.torch_collective import default_pg_timeout
+from lightning.fabric.plugins.environments.cluster_environment import ClusterEnvironment
+from lightning.fabric.plugins.io.checkpoint_io import CheckpointIO
+from lightning.fabric.plugins.precision import Precision
+from lightning.fabric.strategies.launchers.subprocess_script import _SubprocessScriptLauncher
+from lightning.fabric.strategies.parallel import ParallelStrategy
+from lightning.fabric.strategies.strategy import TBroadcast, _BackwardSyncControl
+from lightning.fabric.utilities.distributed import (
+    ReduceOp,
+    _distributed_is_initialized,
+    _get_default_process_group_backend_for_device,
+    _init_dist_connection,
+    _sync_ddp_if_available,
+)
+from lightning.fabric.utilities.rank_zero import rank_zero_only
+from lightning_utilities.core.rank_zero import rank_zero_only as utils_rank_zero_only
+from torch import Tensor
+from torch.nn import Module
+from typing_extensions import override
+
+from litgpt.utils import _THUNDER_AVAILABLE
+
+if TYPE_CHECKING:
+    from thunder import Executor
+
+
+class ThunderDDPStrategy(ParallelStrategy):
+    def __init__(
+        self,
+        accelerator: Optional[Accelerator] = None,
+        parallel_devices: Optional[List[torch.device]] = None,
+        cluster_environment: Optional[ClusterEnvironment] = None,
+        checkpoint_io: Optional[CheckpointIO] = None,
+        precision: Optional[Precision] = None,
+        jit: bool = True,
+        executors: Optional[Tuple[Union["Executor", str], ...]] = None,
+        process_group_backend: Optional[str] = None,
+        timeout: Optional[timedelta] = default_pg_timeout,
+        **kwargs: Any,
+    ):
+        r"""Strategy for Replicated Data Parallel provided by Lightning Thunder.
+
+        .. warning::  This is an :ref:`experimental <versioning:Experimental API>` feature.
+
+        Arguments:
+            jit: Whether to automatically call ``thunder.jit(model)`` if necessary. Disable this if you are manually
+                jitting a function that includes the model.
+
+            executors: The list of Thunder executors to enable. They can be either string aliases for the executors
+                or the actual executor instances.
+
+            \**kwargs: See available parameters in :func:`thunder.distributed.ddp`.
+
+        """
+        if not _THUNDER_AVAILABLE:
+            raise ModuleNotFoundError(str(_THUNDER_AVAILABLE))
+        super().__init__(accelerator=accelerator, checkpoint_io=checkpoint_io, precision=precision)
+        self.parallel_devices = parallel_devices
+        self.cluster_environment: Optional[ClusterEnvironment] = cluster_environment
+
+        if not jit and executors is not None:
+            raise ValueError(f"Passing executors={executors} doesn't have an effect with `jit={jit}`")
+        self.jit = jit
+        self.executors = executors
+        self._num_nodes = 1
+        self._process_group_backend: Optional[str] = process_group_backend
+        self._timeout: Optional[timedelta] = timeout
+        self._backward_sync_control = _ThunderDataParalellBackwardSyncControl()
+        self._ddp_kwargs = kwargs
+
+    @property
+    @override
+    def root_device(self) -> torch.device:
+        assert self.parallel_devices is not None
+        return self.parallel_devices[self.local_rank]
+
+    @property
+    def num_nodes(self) -> int:
+        return self._num_nodes
+
+    @num_nodes.setter
+    def num_nodes(self, num_nodes: int) -> None:
+        # note that world ranks is related to num_nodes, when resetting it, need to reset world ranks
+        self._num_nodes = num_nodes
+
+    @property
+    def num_processes(self) -> int:
+        return len(self.parallel_devices) if self.parallel_devices is not None else 0
+
+    @property
+    @override
+    def distributed_sampler_kwargs(self) -> Dict[str, Any]:
+        return {"num_replicas": self.num_nodes * self.num_processes, "rank": self.global_rank}
+
+    @override
+    def _configure_launcher(self) -> None:
+        assert self.cluster_environment is not None
+        if not self.cluster_environment.creates_processes_externally:
+            self._launcher = _SubprocessScriptLauncher(self.cluster_environment, self.num_processes, self.num_nodes)
+
+    @property
+    def process_group_backend(self) -> Optional[str]:
+        return self._process_group_backend
+
+    @override
+    def _configure_launcher(self) -> None:
+        assert self.cluster_environment is not None
+        self._launcher = _SubprocessScriptLauncher(self.cluster_environment, self.num_processes, self.num_nodes)
+
+    @override
+    def setup_environment(self) -> None:
+        super().setup_environment()
+        self._setup_distributed()
+
+    @override
+    def setup_module(self, module: Module) -> Module:
+        import thunder
+
+        if (cd := thunder.compile_data(module)) is not None:
+            # the module was already jitted
+            if thunder.compile_stats(module).last_traces is not None:
+                raise RuntimeError(
+                    "You already called `thunder.jit()` and generated an execution trace. It's too late to apply the"
+                    " DDP transform. Remove the `forward` call before `fabric.setup()`"
+                )
+            assert cd.is_module  # sanity check
+            ddp_module = thunder.distributed.ddp(cd.fn, **self._ddp_kwargs)
+            # update the compile data state
+            cd.fn = ddp_module
+            cd.process_group_for_ddp = ddp_module.process_group_for_ddp
+            return module
+        else:
+            module = thunder.distributed.ddp(module, **self._ddp_kwargs)
+        if not self.jit:
+            return module
+        return thunder.jit(module, executors=self.executors)
+
+    @override
+    def module_to_device(self, module: Module) -> None:
+        module.to(self.root_device)
+
+    @override
+    def all_reduce(
+        self, tensor: Tensor, group: Optional[Any] = None, reduce_op: Optional[Union[ReduceOp, str]] = "mean"
+    ) -> Tensor:
+        if isinstance(tensor, Tensor):
+            return _sync_ddp_if_available(tensor, group, reduce_op=reduce_op)
+        return tensor
+
+    @override
+    def barrier(self, *args: Any, **kwargs: Any) -> None:
+        if not _distributed_is_initialized():
+            return
+        if torch.distributed.get_backend() == "nccl":
+            torch.distributed.barrier(device_ids=[self.root_device.index])
+        else:
+            torch.distributed.barrier()
+
+    @override
+    def broadcast(self, obj: TBroadcast, src: int = 0) -> TBroadcast:
+        if not _distributed_is_initialized():
+            return obj
+
+        obj = [obj]
+        torch.distributed.broadcast_object_list(obj, src)
+        return obj[0]
+
+    def _setup_distributed(self) -> None:
+        self._set_world_ranks()
+        self._process_group_backend = self._get_process_group_backend()
+        assert self.cluster_environment is not None
+        _init_dist_connection(self.cluster_environment, self._process_group_backend, timeout=self._timeout)
+
+    def _get_process_group_backend(self) -> str:
+        return self._process_group_backend or _get_default_process_group_backend_for_device(self.root_device)
+
+    def _set_world_ranks(self) -> None:
+        if self.cluster_environment is not None:
+            self.cluster_environment.set_global_rank(self.node_rank * self.num_processes + self.local_rank)
+            self.cluster_environment.set_world_size(self.num_nodes * self.num_processes)
+        # `LightningEnvironment.set_global_rank` will do this too, but we cannot rely on that implementation detail
+        # additionally, for some implementations, the setter is a no-op, so it's safer to access the getter
+        rank_zero_only.rank = utils_rank_zero_only.rank = self.global_rank
+
+
+class _ThunderDataParalellBackwardSyncControl(_BackwardSyncControl):
+    def __init__(self):
+        self._enabled = False
+
+    @override
+    def no_backward_sync(self, module: Module, enabled: bool) -> ContextManager:
+        """
+        In Thunder, we cannot use ``module.no_sync()`` because reduction happens at the end of the context manager.
+        It assumes that the user will reuse it across all gradient accumulation iterations:
+
+        .. code-block:: python
+
+            with model.no_sync():
+                for _ in range(len(gradient_accumulation_iters)):
+                    fwd()
+                    bwd()  # uses no-sync-backward trace
+                fwd()
+                bwd()  # uses regular-backward trace
+
+        However, Fabric is designed to the context manager every iteration:
+
+        .. code-block:: python
+
+            for i in range(iters):
+                is_accumulating = (i + 1) % gradient_accumulation_iters != 0
+                ctx = model.no_sync() if is_accumulating else nullcontext()
+                with ctx:
+                    fwd()
+                    bwd()
+
+        So we need to be smart about when to sync grads based on the ``enabled`` value.
+
+        More info in https://github.com/Lightning-AI/lit-thunder-LEGACY/issues/2085
+        """
+        if not getattr(module, "use_ddp", False) and not getattr(module, "use_fsdp", False):
+            raise TypeError(
+                "Blocking backward sync is only possible if the module passed to"
+                f" `{self.__class__.__name__}.no_backward_sync` is applied DDP or FSDP."
+                f" Got: {module.__class__.__name__}."
+            )
+
+        from thunder.distributed import skip_data_parallel_grad_sync
+
+        previous, self._enabled = self._enabled, enabled
+        if enabled:
+            return skip_data_parallel_grad_sync()
+        if not enabled and previous:
+            return _SyncGradsContextManager(module)
+        return nullcontext()
+
+
+class _SyncGradsContextManager:
+    def __init__(self, module: Module) -> None:
+        self._module = module
+
+    @override
+    def __enter__(self) -> None:
+        from thunder.distributed import _sync_grads
+
+        _sync_grads(self._module)
+
+    @override
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        pass

extensions/thunder/strategies/thunder_fsdp.py

@@ -0,0 +1,459 @@
+"""Fabric Strategy to support Thunder FSDP: To be upstreamed into Fabric eventually."""
+
+import shutil
+from contextlib import ExitStack, nullcontext
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, ContextManager, Dict, List, Literal, Optional, Tuple, Union
+
+import torch
+from lightning.fabric.accelerators.accelerator import Accelerator
+from lightning.fabric.plugins.environments.cluster_environment import ClusterEnvironment
+from lightning.fabric.plugins.io.checkpoint_io import CheckpointIO
+from lightning.fabric.plugins.precision import Precision
+from lightning.fabric.strategies.launchers.subprocess_script import _SubprocessScriptLauncher
+from lightning.fabric.strategies.parallel import ParallelStrategy
+from lightning.fabric.strategies.strategy import TBroadcast, _apply_filter, _Sharded, _validate_keys_for_strict_loading
+from lightning.fabric.utilities.distributed import (
+    ReduceOp,
+    _distributed_is_initialized,
+    _get_default_process_group_backend_for_device,
+    _init_dist_connection,
+    _sync_ddp_if_available,
+)
+from lightning.fabric.utilities.imports import _TORCH_GREATER_EQUAL_2_2
+from lightning.fabric.utilities.load import _METADATA_FILENAME, _move_state_into
+from lightning.fabric.utilities.rank_zero import rank_zero_only
+from lightning.fabric.utilities.seed import reset_seed
+from lightning.fabric.utilities.types import _PATH, _Stateful
+from lightning_utilities.core.rank_zero import rank_zero_only as utils_rank_zero_only
+from torch import Tensor
+from torch.nn import Module
+from torch.optim import Optimizer
+from typing_extensions import override
+
+from extensions.thunder.strategies.thunder_ddp import _ThunderDataParalellBackwardSyncControl
+from litgpt.utils import _THUNDER_AVAILABLE
+
+if TYPE_CHECKING:
+    from thunder import Executor
+    from thunder.distributed import FSDPBucketingStrategy, FSDPType
+    from thunder.distributed.checkpoint import StateDictOptions
+
+    _FSDP_TYPE = Union[FSDPType, Literal["ZERO2", "ZERO3"]]
+    _BUCKETING_STRATEGY = Union[FSDPBucketingStrategy, Literal["NONE", "LAYER", "BLOCK"]]
+
+
+class ThunderFSDPStrategy(ParallelStrategy, _Sharded):
+    def __init__(
+        self,
+        accelerator: Optional[Accelerator] = None,
+        parallel_devices: Optional[List[torch.device]] = None,
+        cluster_environment: Optional[ClusterEnvironment] = None,
+        checkpoint_io: Optional[CheckpointIO] = None,
+        precision: Optional[Precision] = None,
+        jit: bool = True,
+        executors: Optional[Tuple[Union["Executor", str], ...]] = None,
+        sharding_strategy: "_FSDP_TYPE" = "ZERO3",
+        bucketing_strategy: "_BUCKETING_STRATEGY" = "NONE",
+        state_dict_type: Literal["full", "sharded"] = "sharded",
+        **kwargs: Any,
+    ):
+        r"""Strategy for Fully Sharded Data Parallel provided by Lightning Thunder.
+
+        .. warning::  This is an :ref:`experimental <versioning:Experimental API>` feature.
+
+        Fully Sharded Training shards the entire model across all available GPUs, allowing you to scale model
+        size, whilst using efficient communication to reduce overhead. In practice, this means we can remain
+        at parity with PyTorch DDP, whilst scaling our model sizes dramatically.
+
+        Arguments:
+            jit: Whether to automatically call ``thunder.jit(model)`` if necessary. Disable this if you are manually
+                jitting a function that includes the model.
+
+            executors: The list of Thunder executors to enable. They can be either string aliases for the executors
+                or the actual executor instances.
+
+            sharding_strategy: Select whether to shard model parameters, gradients, optimizer states, or a combination
+                of them:
+
+                - ``"ZERO3"``: Shards model parameters, gradients, and optimizer states (default).
+                - ``"ZERO2"``: Shards gradients and optimizer states only. Model parameters get replicated.
+
+                Also accepts a :class:`thunder.distributed.FSDPType` enum value.
+
+            bucketing_strategy: Enables combining the collective operations for sets of layers.
+
+                - ``"NONE"``: No bucketing (default).
+                - ``"LAYER"``: Create buckets per layer class.
+                - ``"BLOCK"``: Create buckets per layer block.
+
+                Also accepts a :class:`thunder.distributed.FSDPBucketingStrategy` enum value.
+
+            state_dict_type: The format in which the state of the model and optimizers gets saved into the checkpoint.
+
+                - ``"full"``: The full weights and optimizer states get assembled on rank 0 and saved to a single file
+                  (default).
+                - ``"sharded"``: Each rank saves its shard of weights and optimizer states to a file. The checkpoint is
+                  a folder with as many files as the world size.
+
+            \**kwargs: See available parameters in :func:`thunder.distributed.fsdp`.
+
+        """
+        if not _TORCH_GREATER_EQUAL_2_2:
+            raise ImportError("Thunder's FSDP strategy requires PyTorch 2.2 or higher.")
+        if not _THUNDER_AVAILABLE:
+            raise ModuleNotFoundError(str(_THUNDER_AVAILABLE))
+        super().__init__(accelerator=accelerator, checkpoint_io=checkpoint_io, precision=precision)
+        self.parallel_devices = parallel_devices
+        self.cluster_environment: Optional[ClusterEnvironment] = cluster_environment
+        from thunder.distributed import FSDPBucketingStrategy, FSDPType
+
+        self.sharding_strategy = (
+            FSDPType[sharding_strategy.upper()] if isinstance(sharding_strategy, str) else sharding_strategy
+        )
+        self.bucketing_strategy = (
+            FSDPBucketingStrategy[bucketing_strategy.upper()]
+            if isinstance(bucketing_strategy, str)
+            else bucketing_strategy
+        )
+        if not jit and executors is not None:
+            raise ValueError(f"Passing executors={executors} doesn't have an effect with `jit={jit}`")
+        self.jit = jit
+        self.executors = executors
+        self._state_dict_type = state_dict_type
+        self._backward_sync_control = _ThunderDataParalellBackwardSyncControl()
+        self._fsdp_kwargs = kwargs
+
+    @property
+    @override
+    def root_device(self) -> torch.device:
+        assert self.parallel_devices is not None
+        return self.parallel_devices[self.local_rank]
+
+    @property
+    def num_nodes(self) -> int:
+        return 1
+
+    @property
+    def num_processes(self) -> int:
+        return len(self.parallel_devices) if self.parallel_devices is not None else 0
+
+    @property
+    @override
+    def distributed_sampler_kwargs(self) -> Dict[str, Any]:
+        return {"num_replicas": self.num_nodes * self.num_processes, "rank": self.global_rank}
+
+    @override
+    def _configure_launcher(self) -> None:
+        assert self.cluster_environment is not None
+        if not self.cluster_environment.creates_processes_externally:
+            self._launcher = _SubprocessScriptLauncher(self.cluster_environment, self.num_processes, self.num_nodes)
+
+    @override
+    def setup_environment(self) -> None:
+        super().setup_environment()
+        self._setup_distributed()
+
+    @override
+    def setup_module(self, module: Module) -> Module:
+        import thunder
+
+        if (cd := thunder.compile_data(module)) is not None:
+            # the module was already jitted
+            if thunder.compile_stats(module).last_traces is not None:
+                raise RuntimeError(
+                    "You already called `thunder.jit()` and generated an execution trace. It's too late to apply the"
+                    " FSDP transform. Remove the `forward` call before `fabric.setup()`"
+                )
+            assert cd.is_module  # sanity check
+            fsdp_module = thunder.distributed.fsdp(
+                cd.fn,
+                device=self.root_device,
+                sharding_strategy=self.sharding_strategy,
+                bucketing_strategy=self.bucketing_strategy,
+                **self._fsdp_kwargs,
+            )
+            # update the compile data state
+            cd.fn = fsdp_module
+            cd.process_group_for_ddp = fsdp_module.process_group_for_ddp
+            return module
+        else:
+            module = thunder.distributed.fsdp(
+                module,
+                device=self.root_device,
+                sharding_strategy=self.sharding_strategy,
+                bucketing_strategy=self.bucketing_strategy,
+                **self._fsdp_kwargs,
+            )
+        if not self.jit:
+            return module
+        return thunder.jit(module, executors=self.executors)
+
+    @override
+    def module_to_device(self, module: Module) -> None:
+        pass
+
+    @override
+    def module_init_context(self, empty_init: Optional[bool] = None) -> ContextManager:
+        precision_init_ctx = self.precision.module_init_context()
+        module_sharded_ctx = self.module_sharded_context()
+        stack = ExitStack()
+        if empty_init:
+            # Materialization happens in `setup`. When modules get wrapped by FSDP
+            stack.enter_context(torch.device("meta"))
+        stack.enter_context(precision_init_ctx)
+        stack.enter_context(module_sharded_ctx)
+        return stack
+
+    @override
+    def module_sharded_context(self) -> ContextManager:
+        return nullcontext()
+
+    @override
+    def all_reduce(
+        self, tensor: Tensor, group: Optional[Any] = None, reduce_op: Optional[Union[ReduceOp, str]] = "mean"
+    ) -> Tensor:
+        if isinstance(tensor, Tensor):
+            return _sync_ddp_if_available(tensor, group, reduce_op=reduce_op)
+        return tensor
+
+    @override
+    def barrier(self, *args: Any, **kwargs: Any) -> None:
+        if not _distributed_is_initialized():
+            return
+        if torch.distributed.get_backend() == "nccl":
+            torch.distributed.barrier(device_ids=[self.root_device.index])
+        else:
+            torch.distributed.barrier()
+
+    @override
+    def broadcast(self, obj: TBroadcast, src: int = 0) -> TBroadcast:
+        if not _distributed_is_initialized():
+            return obj
+
+        obj = [obj]
+        torch.distributed.broadcast_object_list(obj, src)
+        return obj[0]
+
+    @override
+    def clip_gradients_norm(
+        self,
+        module: Module,
+        optimizer: Optimizer,
+        max_norm: Union[float, int],
+        norm_type: Union[float, int] = 2.0,
+        error_if_nonfinite: bool = True,
+    ) -> Tensor:
+        raise NotImplementedError
+
+    @override
+    def save_checkpoint(
+        self,
+        path: _PATH,
+        state: Dict[str, Union[Module, Optimizer, Any]],
+        storage_options: Optional[Any] = None,
+        filter: Optional[Dict[str, Callable[[str, Any], bool]]] = None,
+    ) -> None:
+        if storage_options is not None:
+            raise TypeError(
+                "`FSDPStrategy.save_checkpoint(..., storage_options=...)` is not supported because"
+                " `FSDPStrategy` does not use the `CheckpointIO`."
+            )
+        if filter is not None:
+            raise NotImplementedError("Filtering checkpoint paths is not implemented")
+
+        # broadcast the path from rank 0 to ensure all the states are saved in a common path
+        path = Path(self.broadcast(path))
+        if path.is_dir() and self._state_dict_type == "full" and not _is_sharded_checkpoint(path):
+            raise IsADirectoryError(f"The checkpoint path exists and is a directory: {path}")
+
+        from thunder.distributed.checkpoint import StateDictOptions, has_fsdp_modules, save
+
+        modules = [module for module in state.values() if has_fsdp_modules(module)]
+        if len(modules) == 0:
+            raise ValueError(
+                "Could not find a FSDP model in the provided checkpoint state. Please provide the model as"
+                " part of the state like so: `save_checkpoint(..., state={'model': model, ...})`. Make sure"
+                " you set up the model (and optimizers if any) through the strategy before saving the checkpoint."
+            )
+        if len(modules) > 1:
+            raise ValueError(
+                "Found multiple FSDP models in the given state. Saving checkpoints with FSDP is"
+                " currently limited to a single model per checkpoint. To save multiple models, call the"
+                " save method for each model separately with a different path."
+            )
+
+        if self._state_dict_type == "sharded":
+            if _is_full_checkpoint(path):
+                path.unlink()
+            path.mkdir(parents=True, exist_ok=True)
+
+            options = StateDictOptions(full_state_dict=False, cpu_offload=True, rank0_only=False)
+            converted_state, metadata = _get_state_dict(state, filter, options, self.local_rank)
+            save(converted_state, path)
+            if self.global_rank == 0:
+                torch.save(metadata, path / _METADATA_FILENAME)
+
+        elif self._state_dict_type == "full":
+            if _is_sharded_checkpoint(path):
+                shutil.rmtree(path)
+
+            options = StateDictOptions(full_state_dict=True, cpu_offload=True, rank0_only=True)
+            converted_state, metadata = _get_state_dict(state, filter, options, self.local_rank)
+            converted_state.update(metadata)
+            if self.global_rank == 0:
+                torch.save(converted_state, path)
+        else:
+            raise ValueError(f"Unknown state_dict_type: {self._state_dict_type}")
+
+    @override
+    def load_checkpoint(
+        self,
+        path: _PATH,
+        state: Optional[Union[Module, Optimizer, Dict[str, Union[Module, Optimizer, Any]]]] = None,
+        strict: bool = True,
+    ) -> Dict[str, Any]:
+        if not state:
+            raise ValueError(
+                f"Got `FSDPStrategy.load_checkpoint(..., state={state!r})` but a state with at least"
+                " a model instance to reload is required. Pass it in like so:"
+                " `FSDPStrategy.load_checkpoint(..., state={'model': model, ...})`"
+            )
+        # broadcast the path from rank 0 to ensure all the states are loaded from a common path
+        path = Path(self.broadcast(path))
+
+        from thunder.distributed.checkpoint import StateDictOptions, has_fsdp_modules, load, load_model_state_dict
+
+        if isinstance(state, Module):
+            if not _is_full_checkpoint(path):
+                raise ValueError(
+                    "Failed to load checkpoint directly into the model. The given path must be a single file"
+                    f" containing the full state dict: {path}"
+                )
+            state_dict = torch.load(str(path), mmap=True, map_location="cpu")
+            options = StateDictOptions(full_state_dict=True, cpu_offload=True, strict=strict, rank0_only=False)
+            load_model_state_dict(state_dict, _unwrap_tom(state), options, self.local_rank)
+            return {}
+
+        if isinstance(state, Optimizer):
+            raise NotImplementedError(
+                "Loading a single optimizer object from a checkpoint is not supported yet with the FSDP strategy."
+            )
+
+        modules = {key: module for key, module in state.items() if has_fsdp_modules(module)}
+        if len(modules) == 0:
+            raise ValueError(
+                "Could not find a FSDP model in the provided checkpoint state. Please provide the model as"
+                " part of the state like so: `load_checkpoint(..., state={'model': model, ...})`. Make sure"
+                " you set up the model (and optimizers if any) through the strategy before loading the checkpoint."
+            )
+        if len(modules) > 1:
+            raise ValueError(
+                "Found multiple FSDP models in the given state. Loading checkpoints with FSDP is"
+                " currently limited to a single model per checkpoint. To load multiple models, call the"
+                " load method for each model separately with a different path."
+            )
+        optimizers = {key: optim for key, optim in state.items() if isinstance(optim, Optimizer)}
+        module_key, module = list(modules.items())[0]
+        module = _unwrap_tom(module)
+
+        if _is_sharded_checkpoint(path):
+            options = StateDictOptions(full_state_dict=False, cpu_offload=True, strict=strict, rank0_only=False)
+            # Load the DCP state dict, which requires a holder state dict
+            converted_state, _ = _get_state_dict(state, None, options, self.local_rank)
+            load(converted_state, path)
+            load_model_state_dict(converted_state[module_key], module, options, self.local_rank)
+
+            # Load metadata (anything not a module or optimizer)
+            metadata = torch.load(path / _METADATA_FILENAME)
+            requested_metadata_keys = state.keys() - modules.keys() - optimizers.keys()
+            _validate_keys_for_strict_loading(requested_metadata_keys, metadata.keys(), strict=strict)
+            for key in requested_metadata_keys:
+                if key not in metadata:
+                    continue
+                state[key] = metadata.pop(key)
+            # return the remaining metadata that wasn't requested as part of `state`
+            return metadata
+
+        if _is_full_checkpoint(path):
+            options = StateDictOptions(full_state_dict=True, cpu_offload=True, strict=strict, rank0_only=False)
+            if not options.rank0_only or self.local_rank == 0:
+                map_location = "cpu" if options.cpu_offload else None
+                checkpoint = torch.load(str(path), mmap=True, map_location=map_location)
+                load_model_state_dict(checkpoint[module_key], module, options, self.local_rank)
+            else:
+                checkpoint = {}
+
+            requested_metadata_keys = state.keys() - modules.keys() - optimizers.keys()
+            _validate_keys_for_strict_loading(requested_metadata_keys, checkpoint.keys(), strict=strict)
+            # Load metadata (anything not a module or optimizer)
+            _move_state_into(source=checkpoint, destination=state, keys=requested_metadata_keys)
+            # return the remaining metadata that wasn't requested as part of `state`
+            return checkpoint
+
+        raise ValueError(
+            f"The path {str(path)!r} does not point to a valid checkpoint. Make sure the path points to either a"
+            " directory with FSDP checkpoint shards, or a single file with a full checkpoint."
+        )
+
+    def _setup_distributed(self) -> None:
+        reset_seed()
+        self._set_world_ranks()
+        process_group_backend = _get_default_process_group_backend_for_device(self.root_device)
+        assert self.cluster_environment is not None
+        _init_dist_connection(self.cluster_environment, process_group_backend)
+
+    def _set_world_ranks(self) -> None:
+        if self.cluster_environment is not None:
+            self.cluster_environment.set_global_rank(self.node_rank * self.num_processes + self.local_rank)
+            self.cluster_environment.set_world_size(self.num_nodes * self.num_processes)
+        # `LightningEnvironment.set_global_rank` will do this too, but we cannot rely on that implementation detail
+        # additionally, for some implementations, the setter is a no-op, so it's safer to access the getter
+        rank_zero_only.rank = utils_rank_zero_only.rank = self.global_rank
+
+
+def _is_sharded_checkpoint(path: Path) -> bool:
+    """A heuristic check to determine whether the path points to a directory with checkpoint shards."""
+    return path.is_dir() and (path / _METADATA_FILENAME).is_file()
+
+
+def _is_full_checkpoint(path: Path) -> bool:
+    return path.is_file()
+
+
+def _get_state_dict(
+    state: Dict[str, Any],
+    filter: Optional[Dict[str, Callable[[str, Any], bool]]],
+    options: "StateDictOptions",
+    rank: int,
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    from thunder.distributed.checkpoint import get_model_state_dict
+
+    # replace the modules and optimizer objects in the state with their local state dict
+    # and separate the user's metadata
+    converted_state: Dict[str, Any] = {}
+    metadata: Dict[str, Any] = {}
+    for key, obj in state.items():
+        converted: Any
+        if isinstance(obj, Module):
+            converted = get_model_state_dict(_unwrap_tom(obj), options, rank)
+            target_dict = converted_state
+        elif isinstance(obj, Optimizer):
+            # TODO: optimizer support
+            converted = obj.state_dict()
+            target_dict = converted_state
+        else:  # everything not a module or optimizer is considered metadata
+            converted = obj.state_dict() if isinstance(obj, _Stateful) else obj
+            target_dict = metadata
+        _apply_filter(key, filter or {}, converted, target_dict)
+
+    return converted_state, metadata
+
+
+def _unwrap_tom(obj: object) -> object:
+    # TODO: this unwrap won't be required when Fabric's `_unwrap_objects` supports Thunder
+    from thunder import ThunderModule
+
+    if isinstance(obj, ThunderModule):
+        return obj._model
+    return obj

extensions/thunder/unsloth/executor.py

@@ -0,0 +1,284 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import sys
+from pathlib import Path
+from typing import Optional, Tuple
+
+import torch
+from torch import Tensor
+
+import litgpt.model
+from litgpt.model import LLaMAMLP as OriginalLLaMAMLP
+from litgpt.utils import _THUNDER_AVAILABLE
+from thunder.core.proxies import TensorProxy
+from thunder.core.transforms import get_grad, mean_backward, put_grads
+from thunder.extend import OperatorExecutor, register_executor
+from thunder.torch import ne, sum, true_divide
+
+if _THUNDER_AVAILABLE:
+    import thunder
+    import thunder.torch as ltorch
+
+sys.path.append(str(Path(__file__).parent))
+
+import kernels
+
+unsloth_ex = OperatorExecutor("unsloth", version="0.1")
+register_executor(unsloth_ex)
+
+
+"""
+====================
+ Cross Entropy Loss
+====================
+"""
+
+
+def unsloth_cross_entropy_meta(logits: TensorProxy, labels: TensorProxy) -> Tuple[TensorProxy, TensorProxy]:
+    return (
+        TensorProxy(
+            shape=(logits.shape[0],),
+            # the cross entropy kernel only supports float32
+            dtype=thunder.dtypes.float32,
+            device=logits.device,
+            requires_grad=logits.requires_grad,
+        ),
+        TensorProxy(shape=(logits.shape[0],), dtype=thunder.dtypes.float32, device=logits.device, requires_grad=False),
+    )
+
+
+unsloth_cross_entropy = unsloth_ex.register_operator(
+    "unsloth_cross_entropy", meta=unsloth_cross_entropy_meta, fn=kernels.cross_entropy_loss._cross_entropy_forward_impl
+)
+
+
+def unsloth_cross_entropy_backward_impl(dlosses: Tensor, logits: Tensor, labels: Tensor, logsumexp: Tensor) -> Tensor:
+    # clone() because the kernel writes the grads in the logits
+    return kernels.cross_entropy_loss._cross_entropy_backward_impl(dlosses, logits.clone(), logsumexp, labels)
+
+
+def unsloth_cross_entropy_backward_meta(
+    dlosses: TensorProxy, logits: TensorProxy, logsumexp: TensorProxy, labels: TensorProxy
+) -> TensorProxy:
+    return thunder.TensorProxy(like=logits)
+
+
+unsloth_cross_entropy_backward = unsloth_ex.register_operator(
+    "unsloth_cross_entropy_backward", meta=unsloth_cross_entropy_backward_meta, fn=unsloth_cross_entropy_backward_impl
+)
+
+
+def unsloth_cross_entropy_checker(
+    logits: TensorProxy,
+    labels: TensorProxy,
+    weight: Optional[TensorProxy] = None,
+    size_average: Optional[bool] = None,
+    ignore_index: int = -100,
+    reduce: Optional[bool] = None,
+    reduction: str = "mean",
+    label_smoothing: float = 0.0,
+) -> bool:
+    return (
+        weight is None
+        and size_average is None
+        and reduce is None
+        and reduction in ("none", "mean")
+        and ignore_index == -100
+        and label_smoothing == 0.0
+        and logits.device.type == "cuda"
+        and labels.device.type == "cuda"
+    )
+
+
+def cross_entropy_to_unsloth(
+    logits: TensorProxy,
+    labels: TensorProxy,
+    weight: Optional[TensorProxy] = None,
+    size_average: Optional[bool] = None,
+    ignore_index: int = -100,
+    reduce: Optional[bool] = None,
+    reduction: str = "mean",
+    label_smoothing: float = 0.0,
+) -> Tuple[TensorProxy, TensorProxy]:
+    loss, logsumexp = unsloth_cross_entropy(logits, labels)
+    if reduction == "mean":
+        # "mean" reduction is not part of the kernel
+        # TODO: this doesn't consider that all elements could be masked, causing a division by 0
+        n_items = sum(ne(labels, -100))
+        loss = true_divide(sum(loss), n_items)
+    elif reduction != "none":
+        raise NotImplementedError(reduction)
+    return loss, logsumexp
+
+
+def unsloth_cross_entropy_grad(
+    logits: TensorProxy,
+    labels: TensorProxy,
+    weight: Optional[TensorProxy] = None,
+    size_average: Optional[bool] = None,
+    ignore_index: int = -100,
+    reduce: Optional[bool] = None,
+    reduction: str = "mean",
+    label_smoothing: float = 0.0,
+) -> TensorProxy:
+    loss, logsumexp = cross_entropy_to_unsloth(**locals())
+    grad = get_grad(loss)
+    if reduction == "mean":
+        grad = mean_backward(logsumexp.ndim, logsumexp.shape, (0,), grad)
+    logits_grad = unsloth_cross_entropy_backward(grad, logits, labels, logsumexp)
+    put_grads((logits,), (logits_grad,))
+    return loss
+
+
+# registers as cross entropy implementation, including the execution transform and now a grad transform
+unsloth_ex.register_implementation(
+    ltorch.cross_entropy,
+    checker=unsloth_cross_entropy_checker,
+    execution_transform=lambda *args: cross_entropy_to_unsloth(*args)[0],
+    grad_transform=unsloth_cross_entropy_grad,
+)
+
+
+"""
+=========
+ RMSNorm
+=========
+
+The RMSNorm kernel is not integrated because it's not numerically equal and it doesn't compute the gradient for the
+weight, just for the input.
+"""
+
+
+"""
+========
+ SwiGLU
+========
+"""
+
+
+def swiglu(e: torch.Tensor, g: torch.Tensor) -> torch.Tensor:
+    return torch.nn.functional.silu(e) * g
+
+
+class ThunderLLaMAMLP(OriginalLLaMAMLP):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x_fc_1 = self.fc_1(x)
+        x_fc_2 = self.fc_2(x)
+        x = swiglu(x_fc_1, x_fc_2)
+        return self.proj(x)
+
+
+litgpt.model.LLaMAMLP = ThunderLLaMAMLP
+
+
+def swiglu_forward_meta(e: TensorProxy, g: TensorProxy) -> TensorProxy:
+    return TensorProxy(like=e)
+
+
+litgpt_swiglu = unsloth_ex.register_operator("litgpt_swiglu", meta=swiglu_forward_meta, fn=swiglu, replaces=swiglu)
+
+
+unsloth_swiglu_forward = unsloth_ex.register_operator(
+    "unsloth_swiglu_forward", meta=swiglu_forward_meta, fn=lambda *args: kernels.swiglu_fg_kernel(*args)
+)
+
+
+def unsloth_swiglu_backward_meta(DW: TensorProxy, e: TensorProxy, g: TensorProxy) -> Tuple[TensorProxy, TensorProxy]:
+    return TensorProxy(like=g), TensorProxy(like=e)
+
+
+def unsloth_swiglu_backward_fn(DW: Tensor, e: Tensor, g: Tensor) -> Tuple[Tensor, Tuple]:
+    B, T, n_embd = e.shape
+    e = e.view(-1, n_embd)
+    g = g.view(-1, n_embd)
+    DW, e, g = kernels.swiglu_DWf_DW_dfg_kernel(DW, e, g)
+    e = e.view(B, T, n_embd)
+    g = g.view(B, T, n_embd)
+    return g, e
+
+
+unsloth_swiglu_backward = unsloth_ex.register_operator(
+    "unsloth_swiglu_backward", meta=unsloth_swiglu_backward_meta, fn=unsloth_swiglu_backward_fn
+)
+
+
+def swiglu_to_unsloth_checker(e: TensorProxy, g: TensorProxy) -> bool:
+    return e.device.type == "cuda" and g.device.type == "cuda"
+
+
+def unsloth_swiglu_grad(e: TensorProxy, g: TensorProxy) -> TensorProxy:
+    h = unsloth_swiglu_forward(**locals())
+    grad = get_grad(h)
+    e_grad, g_grad = unsloth_swiglu_backward(grad, e, g)
+    put_grads((e, g), (e_grad, g_grad))
+    return h
+
+
+unsloth_ex.register_implementation(
+    litgpt_swiglu,
+    checker=swiglu_to_unsloth_checker,
+    execution_transform=unsloth_swiglu_forward,
+    grad_transform=unsloth_swiglu_grad,
+)
+
+
+"""
+======
+ RoPE
+======
+"""
+
+
+def apply_rope_meta(x: TensorProxy, cos: TensorProxy, sin: TensorProxy) -> TensorProxy:
+    return TensorProxy(like=x)
+
+
+apply_rope = unsloth_ex.register_operator(
+    "litgpt_apply_rope", like=apply_rope_meta, fn=litgpt.model.apply_rope, replaces=litgpt.model.apply_rope
+)
+
+
+def unsloth_apply_rope_meta(
+    Q: TensorProxy, cos: TensorProxy, sin: TensorProxy
+) -> Tuple[TensorProxy, TensorProxy, TensorProxy, int, int, int]:
+    batch, n_heads, seq_len, head_dim = Q.shape
+    assert seq_len <= cos.shape[-2]
+    BLOCK_SIZE, num_warps = kernels.calculate_settings(head_dim // 2)
+    div, mod = divmod(n_heads, kernels.rope_embedding.ROPE_GROUP_SIZE)
+    n_groups = div + (mod != 0)
+    return TensorProxy(like=Q), cos, sin, n_groups, BLOCK_SIZE, num_warps
+
+
+unsloth_apply_rope = unsloth_ex.register_operator(
+    "unsloth_apply_rope", meta=unsloth_apply_rope_meta, fn=kernels._rope_embedding_forward_impl
+)
+
+
+def unsloth_apply_rope_backward_meta(
+    dY: TensorProxy, cos: TensorProxy, sin: TensorProxy, n_groups: int, BLOCK_SIZE: int, num_warps: int
+) -> TensorProxy:
+    return TensorProxy(like=dY)
+
+
+unsloth_apply_rope_backward = unsloth_ex.register_operator(
+    "unsloth_apply_rope_backward", meta=unsloth_apply_rope_backward_meta, fn=kernels._rope_embedding_backward_impl
+)
+
+
+def apply_rope_to_unsloth_checker(x: TensorProxy, cos: TensorProxy, sin: TensorProxy) -> bool:
+    return len(x.shape) == 4 and x.device.type == "cuda" and cos.device.type == "cuda" and sin.device.type == "cuda"
+
+
+def unsloth_apply_rope_grad(x: TensorProxy, cos: TensorProxy, sin: TensorProxy) -> TensorProxy:
+    Q, cos, sin, n_groups, BLOCK_SIZE, num_warps = unsloth_apply_rope(x, cos, sin)
+    dY = get_grad(Q)
+    dX = unsloth_apply_rope_backward(dY, cos, sin, n_groups, BLOCK_SIZE, num_warps)
+    put_grads((x,), (dX,))
+    return Q
+
+
+unsloth_ex.register_implementation(
+    apply_rope,
+    checker=apply_rope_to_unsloth_checker,
+    execution_transform=lambda *args: unsloth_apply_rope(*args)[0],
+    grad_transform=unsloth_apply_rope_grad,
+)

extensions/thunder/unsloth/kernels/__init__.py

@@ -0,0 +1,4 @@
+from .cross_entropy_loss import _cross_entropy_backward_impl, _cross_entropy_forward_impl  # noqa: F401
+from .rope_embedding import ROPE_GROUP_SIZE, _rope_embedding_backward_impl, _rope_embedding_forward_impl  # noqa: F401
+from .swiglu import swiglu_DWf_DW_dfg_kernel, swiglu_fg_kernel  # noqa: F401
+from .utils import calculate_settings  # noqa: F401

extensions/thunder/unsloth/kernels/cross_entropy_loss.py

@@ -0,0 +1,285 @@
+# Copyright 2023-present Daniel Han-Chen & the Unsloth team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from litgpt.utils import _TRITON_AVAILABLE
+
+from .utils import MAX_FUSED_SIZE, calculate_settings
+
+if _TRITON_AVAILABLE:
+    import triton
+    import triton.language as tl
+
+
+@triton.jit
+def _cross_entropy_forward(
+    logits_ptr,
+    logits_row_stride,
+    loss_ptr,
+    logsumexp_ptr,
+    labels_ptr,
+    VOCAB_SIZE: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    """
+    Cross Entropy Loss = 1/n sum [ -yi log(Pi) ]
+    Pi = exp(xi) / sum(exp(xi))
+    CE_i = -y log(p) = -y log[ exp(x) / sum(exp(x)) ]
+         = -y [ x - log[sum(exp(x))] ]
+         = y * (log[sum(exp(x))] - x)
+    If y == 0: CE_i = 0
+    If y == 1: CE_i = logsumexp - x
+
+    logsumexp is also stable
+    Take    y =         log[sum(exp(x))]
+       exp(y) =             sum(exp(x))
+       exp(y) =             sum(exp(x - c)*exp(c)) Since e^(x-c)*e^c = e^x
+       exp(y) =      exp(c)*sum(exp(x - c))
+           y  = log(exp(c)*sum(exp(x - c)))
+           y  = c + log[sum(exp(x - c))]
+    This means we can set c = max(x) to make sure
+    exp(x - c) always is exp(x - max(x)).
+    This ensures exp(x - max(x))'s maximum is 1 as exp(0) = 1.
+    """
+    row_idx = tl.program_id(0)
+    logits_ptr += row_idx * logits_row_stride.to(tl.int64)
+    loss_ptr += row_idx
+    logsumexp_ptr += row_idx
+    labels_ptr += row_idx
+
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < VOCAB_SIZE
+
+    label_idx = tl.load(labels_ptr).to(tl.int32)
+    logits = tl.load(logits_ptr + col_offsets, mask=mask, other=-float("inf")).to(tl.float32)
+    c = tl.max(logits, 0)
+    logsumexp = c + tl.log(tl.sum(tl.exp(logits - c), 0))
+
+    if label_idx != -100:
+        x = tl.load(logits_ptr + label_idx).to(tl.float32)
+        loss = logsumexp - x
+    else:
+        loss = 0.0
+    tl.store(logsumexp_ptr, logsumexp)
+    tl.store(loss_ptr, loss)
+
+
+pass
+
+
+@triton.jit
+def _chunked_cross_entropy_forward(
+    logits_ptr,
+    logits_row_stride,
+    loss_ptr,
+    logsumexp_ptr,
+    labels_ptr,
+    VOCAB_SIZE: tl.constexpr,
+    N_CHUNKS: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    """
+    256K vocab divided in 4 chunks
+
+    |-65536-| |-65536-| |-65536-| |-65536-|
+    |-------| |-------| |-------| |-------|
+    |-------| |-------| |-------| |-------|
+
+    If y == 0: CE_i = 0
+    If y == 1: CE_i = logsumexp - x
+
+    Notice we can do logsumexp for each chunk and then
+    logsumexp[chunk_sum(logsumexp)] == logsumexp
+
+    chunk_sum = log[chunk_sum(logsumexp)]
+              = log[exp(logsumexp(a)) + ... + exp(logsumexp(z))]
+              = log[exp(log[sum(exp(a))]) + ... + exp(log[sum(exp(z))])]
+              = log[sum(exp(a)) + ... + sum(exp(z))]
+              = logsumexp(x)
+
+    This means we can perform a logsumexp for each chunk, then do a
+    final logsumexp reduction!
+
+    Ie do: logsumexp(chunked_logsumexp) - x
+    """
+    row_idx = tl.program_id(0)
+    chunk_idx = tl.program_id(1)
+    logits_ptr += row_idx * logits_row_stride.to(tl.int64)
+    loss_ptr += row_idx
+    logsumexp_ptr += row_idx * N_CHUNKS + chunk_idx
+    labels_ptr += row_idx
+
+    col_offsets = chunk_idx * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < VOCAB_SIZE
+
+    label_idx = tl.load(labels_ptr).to(tl.int32)
+    logits = tl.load(logits_ptr + col_offsets, mask=mask, other=-float("inf")).to(tl.float32)
+    c = tl.max(logits, 0)
+    logsumexp = c + tl.log(tl.sum(tl.exp(logits - c), 0))
+
+    if chunk_idx == 0:
+        # logsumexp(chunked_logsumexp) - x
+        # Do the -x separately
+        if label_idx != -100:
+            x = tl.load(logits_ptr + label_idx).to(tl.float32)
+            loss = -1.0 * x
+        else:
+            loss = 0.0
+        tl.store(loss_ptr, loss)
+    pass
+    tl.store(logsumexp_ptr, logsumexp)
+
+
+pass
+
+
+@triton.jit
+def _cross_entropy_backward(
+    logits_ptr,
+    logits_row_stride,
+    dloss_ptr,
+    dloss_row_stride,
+    logsumexp_ptr,
+    labels_ptr,
+    VOCAB_SIZE: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    """
+    CE_i = -y log(P) = y * (log[sum(exp(x))] - x)
+    dC/dx = d/dx (y * log[sum(exp(x))] - x * y)
+
+    From https://en.wikipedia.org/wiki/LogSumExp
+    d/dx logsumexp = exp(x) / sum(exp(x)) = softmax(x)
+
+    dC/dx = y * exp(x) / sum(exp(x)) - d/dx (x * y)
+    dC/dx = y * exp[ log[exp(x) / sum(exp(x))] ] using x = exp(log(x)) trick
+    dC/dx = y * exp[x - logsumexp] - d/dx (x * y)
+
+    If y == 0: dC/dx = 0
+    If y == 1 and x == label: dC/dlabel = exp[x - logsumexp] - 1
+    If y == 1 and x != label: dC/dx     = exp[x - logsumexp]
+    """
+    row_idx = tl.program_id(0)
+    block_idx = tl.program_id(1)
+
+    logits_ptr += row_idx * logits_row_stride.to(tl.int64)
+    dloss_ptr += row_idx * dloss_row_stride
+    col_offsets = block_idx * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < VOCAB_SIZE
+    label_idx = tl.load(labels_ptr + row_idx).to(tl.int32)
+
+    if label_idx != -100:
+        dloss = tl.load(dloss_ptr)
+    else:
+        dloss = 0.0
+
+    x = tl.load(logits_ptr + col_offsets, mask=mask, other=-float("inf")).to(tl.float32)
+    logsumexp = tl.load(logsumexp_ptr + row_idx)
+    y = tl.exp(x - logsumexp)
+    y = tl.where(
+        col_offsets == label_idx,
+        y - 1.0,  # exp(x - logsumexp) - 1
+        y,  # exp(x - logsumexp)
+    )
+
+    # If y == 0: dC/dx = 0 ==> we already masked it to be = 0, so dloss = 0.
+    tl.store(logits_ptr + col_offsets, dloss * y, mask=mask)
+
+
+pass
+
+
+def _cross_entropy_forward_impl(logits, labels):
+    n_rows, vocab_size = logits.shape
+
+    div, mod = divmod(vocab_size, MAX_FUSED_SIZE)
+    n_chunks = div + (mod != 0)
+    losses = torch.empty(n_rows, dtype=torch.float32, device="cuda")
+
+    if n_chunks == 1:
+        # For small vocabs <= 65336 like Llama, Mistral
+        BLOCK_SIZE, num_warps = calculate_settings(vocab_size)
+        logsumexp = torch.empty(n_rows, dtype=torch.float32, device="cuda")
+
+        _cross_entropy_forward[(n_rows,)](
+            logits,
+            logits.stride(0),
+            losses,
+            logsumexp,
+            labels,
+            VOCAB_SIZE=vocab_size,
+            BLOCK_SIZE=BLOCK_SIZE,
+            num_warps=num_warps,
+        )
+    else:
+        # For large vocabs > 65336 like Gemma 256K
+        logsumexp = torch.empty(
+            (
+                n_rows,
+                n_chunks,
+            ),
+            dtype=torch.float32,
+            device="cuda",
+        )
+
+        _chunked_cross_entropy_forward[
+            (
+                n_rows,
+                n_chunks,
+            )
+        ](
+            logits,
+            logits.stride(0),
+            losses,
+            logsumexp,
+            labels,
+            VOCAB_SIZE=vocab_size,
+            N_CHUNKS=n_chunks,
+            BLOCK_SIZE=MAX_FUSED_SIZE,
+            num_warps=32,
+        )
+        # logsumexp(chunked_logsumexp) - x
+        # Do the -x separately
+        logsumexp = torch.logsumexp(logsumexp, dim=1)  # Row sum
+        losses += logsumexp
+        losses.masked_fill_(labels == -100, 0)  # Don't forget to mask padding out!
+
+    return losses, logsumexp
+
+
+def _cross_entropy_backward_impl(dlosses, logits, logsumexp, labels):
+    n_rows, vocab_size = logits.shape
+
+    BLOCK_SIZE = 4096
+    div, mod = divmod(vocab_size, BLOCK_SIZE)
+    n_blocks = div + (mod != 0)
+
+    _cross_entropy_backward[
+        (
+            n_rows,
+            n_blocks,
+        )
+    ](
+        logits,
+        logits.stride(0),
+        dlosses,
+        dlosses.stride(0),
+        logsumexp,
+        labels,
+        VOCAB_SIZE=vocab_size,
+        BLOCK_SIZE=BLOCK_SIZE,
+        num_warps=8,
+    )
+    return logits

extensions/thunder/unsloth/kernels/rope_embedding.py

@@ -0,0 +1,154 @@
+# Copyright 2023-present Daniel Han-Chen & the Unsloth team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from litgpt.utils import _TRITON_AVAILABLE
+
+from .utils import calculate_settings
+
+if _TRITON_AVAILABLE:
+    import triton
+    import triton.language as tl
+
+ROPE_GROUP_SIZE = 4
+
+
+@triton.heuristics(
+    {
+        "BACKWARD_PASS": lambda args: args["BACKWARD_PASS"],
+    }
+)
+@triton.jit
+def _rope_embedding(
+    Q,
+    Q_row_stride,
+    cos,
+    cos_row_stride,
+    sin,
+    sin_row_stride,
+    seqlen,
+    head_dim: tl.constexpr,
+    n_heads: tl.constexpr,
+    BACKWARD_PASS: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+    ROPE_GROUP_SIZE: tl.constexpr = 4,
+):
+    """
+    Calculates the RoPE Embedding quickly
+    RoPE is Q * cos + rotate_half(Q) * sin
+    See our blog post for more info
+    """
+    row_position = tl.program_id(0)
+    group_head_position = tl.program_id(1)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    half_head_dim = head_dim // 2
+    mask = col_offsets < half_head_dim
+
+    sin1 = tl.load(sin + (row_position % seqlen) * sin_row_stride + half_head_dim * 0 + col_offsets, mask=mask, other=0)
+    cos1 = tl.load(cos + (row_position % seqlen) * cos_row_stride + half_head_dim * 0 + col_offsets, mask=mask, other=0)
+
+    if BACKWARD_PASS:
+        # See our blog post for more info.
+        sin1 = -sin1
+    pass
+
+    # [TODO] Autotune ROPE_GROUP_SIZE to be 1, 2, 4, 8
+    head_start = group_head_position * ROPE_GROUP_SIZE
+    head_end = min((head_start + ROPE_GROUP_SIZE), n_heads)
+
+    # 10% Faster kernel from [HuyNguyen-hust](https://github.com/unslothai/unsloth/pull/238)
+    for k in range(head_start, head_end):
+        offs_q1 = row_position * Q_row_stride + k * head_dim + col_offsets
+        offs_q2 = row_position * Q_row_stride + k * head_dim + col_offsets + half_head_dim
+
+        # For Gemma - sometimes RoPE must be done in float32 and not bfloat16
+        Q1 = tl.load(Q + offs_q1, mask=mask, other=0).to(sin1.dtype)
+        Q2 = tl.load(Q + offs_q2, mask=mask, other=0).to(sin1.dtype)
+
+        tl.store(Q + offs_q1, Q1 * cos1 - Q2 * sin1, mask=mask)
+        tl.store(Q + offs_q2, Q2 * cos1 + Q1 * sin1, mask=mask)
+    pass
+
+
+pass
+
+
+def _rope_embedding_forward_impl(Q, cos, sin):
+    Q = Q.transpose(1, 2).clone()
+    cos, sin = cos.squeeze(), sin.squeeze()
+    batch, seq_len, n_heads, head_dim = Q.shape
+    Q = Q.reshape(batch * seq_len, n_heads * head_dim)
+    n_rows, n_cols = Q.shape
+    assert seq_len <= cos.shape[0]
+
+    # [TODO] Changing blocksize to head_dim//2 seems to have
+    # some concurrency / un-deterministic issues.
+    BLOCK_SIZE, num_warps = calculate_settings(head_dim // 2)  # (head_dim//2)
+
+    # group_size = 4 # 4 or 8, too large group_size can hurt performance.
+    div, mod = divmod(n_heads, ROPE_GROUP_SIZE)
+    n_groups = div + (mod != 0)
+
+    _rope_embedding[
+        (
+            n_rows,
+            n_groups,
+        )
+    ](
+        Q,
+        Q.stride(0),
+        cos,
+        cos.stride(0),
+        sin,
+        sin.stride(0),
+        seq_len,
+        head_dim,
+        n_heads,
+        BACKWARD_PASS=False,
+        BLOCK_SIZE=BLOCK_SIZE,
+        num_warps=num_warps,
+    )
+    Q = Q.view(batch, seq_len, n_heads, head_dim)
+    Q = Q.transpose(1, 2)
+    return Q, cos, sin, n_groups, BLOCK_SIZE, num_warps
+
+
+def _rope_embedding_backward_impl(dY, cos, sin, n_groups, BLOCK_SIZE, num_warps):
+    dY = dY.transpose(1, 2)
+    batch, seq_len, n_heads, head_dim = dY.shape
+    dY = dY.reshape(batch * seq_len, n_heads * head_dim)
+    # Must be reshape not view
+    n_rows, n_cols = dY.shape
+
+    _rope_embedding[
+        (
+            n_rows,
+            n_groups,
+        )
+    ](
+        dY,
+        dY.stride(0),
+        cos,
+        cos.stride(0),
+        sin,
+        sin.stride(0),
+        seq_len,
+        head_dim,
+        n_heads,
+        BACKWARD_PASS=True,
+        BLOCK_SIZE=BLOCK_SIZE,
+        num_warps=num_warps,
+    )
+    dY = dY.view(batch, seq_len, n_heads, head_dim)
+    dY = dY.transpose(1, 2)
+    return dY

extensions/thunder/unsloth/kernels/swiglu.py

@@ -0,0 +1,134 @@
+# Copyright 2023-present Daniel Han-Chen & the Unsloth team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from litgpt.utils import _TRITON_AVAILABLE
+
+if _TRITON_AVAILABLE:
+    import triton
+    import triton.language as tl
+
+
+@triton.jit
+def _fg_kernel(
+    e,
+    g,
+    h,
+    n_elements,
+    BLOCK_SIZE: tl.constexpr,
+):
+    block_idx = tl.program_id(0)
+    offsets = block_idx * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+    mask = offsets < n_elements
+
+    e_row = tl.load(e + offsets, mask=mask, other=0).to(tl.float32)
+    g_row = tl.load(g + offsets, mask=mask, other=0)  # .to(tl.float32)
+
+    # f = e * sigmoid(e)
+    f_row = e_row * tl.sigmoid(e_row)  # e_row / (1 + tl.exp(-e_row))
+    f_row = f_row.to(g_row.dtype)  # Exact copy from HF
+    # h = f * g
+    h_row = f_row * g_row
+
+    # Store h
+    tl.store(h + offsets, h_row, mask=mask)
+
+
+pass
+
+
+def swiglu_fg_kernel(e, g):
+    batch, seq_len, hd = e.shape
+    n_elements = e.numel()
+    h = torch.empty((batch, seq_len, hd), dtype=e.dtype, device="cuda")
+    grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
+    _fg_kernel[grid](
+        e,
+        g,
+        h,
+        n_elements,
+        BLOCK_SIZE=1024,
+    )
+    return h
+
+
+pass
+
+
+@triton.jit
+def _DWf_DW_dfg_kernel(
+    DW,
+    e,
+    g,
+    n_elements,
+    BLOCK_SIZE: tl.constexpr,
+):
+    """
+    e = e.float()
+    se = 1.0 / (1.0 + torch.exp(-e))
+    f = (se * e).to(dtype)
+    h = f * g
+    df = DW * f
+    dg = DW * g
+    de = (dg.float() * se * (1.0 + e * (1.0 - se))).to(dtype)
+    """
+    block_idx = tl.program_id(0)
+    offsets = block_idx * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+    mask = offsets < n_elements
+
+    DW_row = tl.load(DW + offsets, mask=mask, other=0)  # .to(tl.float32)
+    e_row = tl.load(e + offsets, mask=mask, other=0).to(tl.float32)
+    g_row = tl.load(g + offsets, mask=mask, other=0)  # .to(tl.float32)
+
+    # e = e.float()
+    # se = 1.0 / (1.0 + torch.exp(-e))
+    se_row = tl.sigmoid(e_row)  # 1.0 / (1.0 + tl.exp(-e_row))
+    # f = (se * e).to(dtype)
+    f_row = se_row * e_row
+    f_row = f_row.to(DW_row.dtype)
+    # h = f * g
+    h_row = f_row * g_row
+    # df = DW * f
+    df_row = DW_row * f_row
+    # dg = DW * g
+    dg_row = DW_row * g_row
+    # de = (dg.float() * se * (1.0 + e * (1.0 - se))).to(dtype)
+    de_row = dg_row.to(tl.float32) * se_row * (1.0 + e_row * (1.0 - se_row))
+    de_row = de_row.to(DW_row.dtype)
+
+    # Store derivatives in buffers
+    tl.store(DW + offsets, h_row, mask=mask)  # h  = f * g
+    tl.store(e + offsets, df_row, mask=mask)  # df = DW * f
+    tl.store(g + offsets, de_row, mask=mask)  # de
+
+
+pass
+
+
+def swiglu_DWf_DW_dfg_kernel(DW, e, g):
+    batch_seq_len, hd = e.shape
+    n_elements = e.numel()
+    grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
+    _DWf_DW_dfg_kernel[grid](
+        DW,
+        e,
+        g,
+        n_elements,
+        BLOCK_SIZE=1024,
+    )
+    return DW, e, g
+
+
+pass

extensions/thunder/unsloth/kernels/utils.py

@@ -0,0 +1,41 @@
+# Copyright 2023-present Daniel Han-Chen & the Unsloth team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from litgpt.utils import _TRITON_AVAILABLE
+
+if _TRITON_AVAILABLE:
+    import triton
+
+MAX_FUSED_SIZE = 65536  # 2**16
+next_power_of_2 = triton.next_power_of_2
+
+
+def calculate_settings(n):
+    BLOCK_SIZE = next_power_of_2(n)
+    if BLOCK_SIZE > MAX_FUSED_SIZE:
+        raise RuntimeError(
+            f"Cannot launch Triton kernel since n = {n} exceeds the maximum CUDA blocksize = {MAX_FUSED_SIZE}."
+        )
+    num_warps = 4
+    if BLOCK_SIZE >= 32768:
+        num_warps = 32
+    elif BLOCK_SIZE >= 8192:
+        num_warps = 16
+    elif BLOCK_SIZE >= 2048:
+        num_warps = 8
+    return BLOCK_SIZE, num_warps
+
+
+pass

extensions/xla/finetune/adapter.py

@@ -0,0 +1,285 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import lightning as L
+import torch
+import torch_xla.core.xla_model as xm
+from lightning.fabric.accelerators import XLAAccelerator
+from lightning.fabric.loggers import CSVLogger
+from lightning.fabric.strategies import XLAFSDPStrategy
+from lightning.fabric.utilities import ThroughputMonitor, measure_flops
+
+from litgpt.adapter import GPT, Block, Config, adapter_filter, mark_only_adapter_as_trainable
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import check_valid_checkpoint_dir, chunked_cross_entropy, estimate_flops, lazy_load, num_parameters
+
+# support running without installing as a package
+wd = Path(__file__).parents[3].resolve()
+sys.path.append(str(wd))
+
+from xla.generate.base import generate  # noqa: E402
+from xla.scripts.prepare_alpaca import generate_prompt  # noqa: E402
+from xla.utils import rank_print, sequential_load_and_fsdp_wrap  # noqa: E402
+
+eval_interval = 200
+save_interval = 200
+eval_iters = 100
+eval_max_new_tokens = 100
+log_interval = 1
+devices = XLAAccelerator.auto_device_count()
+# the state of very large models will not fit on the system RAM, this flag can alleviate it by loading it on each rank
+# sequentially
+reduce_cpu_memory_usage_during_load = False
+
+# Hyperparameters
+learning_rate = 3e-3
+batch_size = 4
+micro_batch_size = batch_size
+gradient_accumulation_iters = batch_size // micro_batch_size
+assert gradient_accumulation_iters > 0
+epoch_size = 50000  # train dataset size
+num_epochs = 5
+max_iters = num_epochs * (epoch_size // micro_batch_size) // devices
+weight_decay = 0.02
+warmup_steps = 2 * (epoch_size // micro_batch_size) // devices // gradient_accumulation_iters  # 2 epochs
+
+hparams = {k: v for k, v in locals().items() if isinstance(v, (int, float, str)) and not k.startswith("_")}
+
+
+def setup(
+    *,
+    data_dir: Path = Path("data/alpaca"),
+    checkpoint_dir: Path = Path("checkpoints/tiiuae/falcon-7b"),
+    out_dir: Path = Path("out/adapter/alpaca"),
+    precision: str = "bf16-true",
+) -> None:
+    if devices > 1:
+        strategy = XLAFSDPStrategy(
+            auto_wrap_policy={Block},
+            activation_checkpointing_policy={Block},
+            state_dict_type="full",  # change to "sharded" in multi-host environments where the filesystem is not shared
+            sequential_save=True,
+        )
+    else:
+        strategy = "auto"
+    logger = CSVLogger(out_dir.parent, out_dir.name, flush_logs_every_n_steps=log_interval)
+    fabric = L.Fabric(devices=devices, strategy=strategy, precision=precision, loggers=logger)
+    rank_print(fabric, hparams)
+    fabric.launch(main, data_dir, checkpoint_dir, out_dir)
+
+
+def main(fabric: L.Fabric, data_dir: Path, checkpoint_dir: Path, out_dir: Path) -> None:
+    check_valid_checkpoint_dir(checkpoint_dir)
+
+    fabric.seed_everything(1337)  # same seed for every process to init model (FSDP)
+
+    if fabric.global_rank == 0:
+        os.makedirs(out_dir, exist_ok=True)
+
+    train_data = torch.load(data_dir / "train.pt")
+    val_data = torch.load(data_dir / "test.pt")
+
+    config = Config.from_name(name=checkpoint_dir.name, adapter_start_layer=0)
+    checkpoint_path = checkpoint_dir / "lit_model.pth"
+    rank_print(fabric, f"Loading model {str(checkpoint_path)!r} with {config.__dict__}")
+
+    if reduce_cpu_memory_usage_during_load:
+        model = sequential_load_and_fsdp_wrap(fabric, lambda: GPT(config), checkpoint_path)
+    else:
+        with fabric.init_module(empty_init=False):
+            model = GPT(config)
+        checkpoint = lazy_load(checkpoint_path)
+        # strict=False because missing keys due to adapter weights not contained in state dict
+        model.load_state_dict(checkpoint, strict=False)
+
+    model = fabric.setup_module(model)
+    # mark as trainable only after sharding due to https://github.com/pytorch/xla/pull/5484
+    mark_only_adapter_as_trainable(model)
+    # these are not correct in the sharding case
+    rank_print(fabric, f"Number of trainable parameters: {num_parameters(model, requires_grad=True):,}")
+    rank_print(fabric, f"Number of non-trainable parameters: {num_parameters(model, requires_grad=False):,}")
+
+    trainable_params = [p for p in model.parameters() if p.requires_grad]
+    optimizer = torch.optim.SGD(trainable_params, lr=learning_rate)
+    optimizer = fabric.setup_optimizers(optimizer)
+
+    fabric.seed_everything(1337 + fabric.global_rank)
+
+    train_time = time.perf_counter()
+    train(fabric, model, optimizer, train_data, val_data, checkpoint_dir, out_dir)
+    rank_print(fabric, f"Training time: {(time.perf_counter() - train_time):.2f}s")
+
+    # Save the final checkpoint at the end of training
+    save_path = out_dir / "lit_model_adapter_finetuned.pth"
+    save_adapter_checkpoint(fabric, model, save_path)
+
+
+def train(
+    fabric: L.Fabric,
+    model: GPT,
+    optimizer: torch.optim.Optimizer,
+    train_data: List[Dict],
+    val_data: List[Dict],
+    checkpoint_dir: Path,
+    out_dir: Path,
+) -> None:
+    tokenizer = Tokenizer(checkpoint_dir)
+    longest_seq_length = get_longest_seq_length(train_data)
+    model.max_seq_length = longest_seq_length
+    # to avoid recompilation, this script is configured to pad batches to the `longest_seq_length`
+    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}"
+    )
+
+    with torch.device("meta"):
+        meta_model = GPT(model.config)
+        mark_only_adapter_as_trainable(meta_model)
+        # "estimated" is not as precise as "measured". Estimated is optimistic but widely used in the wild.
+        # When comparing MFU or FLOP numbers with other projects that use estimated FLOPs,
+        # consider passing `flops_per_batch=estimated_flops` instead
+        estimated_flops = estimate_flops(meta_model, training=True) * micro_batch_size
+        rank_print(fabric, f"Estimated TFLOPs: {estimated_flops * fabric.world_size / 1e12:.2f}")
+        # this assumes that all samples have a fixed length equal to the longest sequence length
+        # which is most likely false during finetuning
+        x = torch.randint(0, 1, (micro_batch_size, longest_seq_length))
+        forward_fn = lambda: meta_model(x)  # noqa: F821
+        loss_fn = lambda y: chunked_cross_entropy(y, x, chunk_size=0)  # noqa: F821
+        measured_flops = measure_flops(meta_model, forward_fn, loss_fn)
+        rank_print(fabric, f"Measured TFLOPs: {measured_flops * fabric.world_size / 1e12:.2f}")
+        del meta_model, x
+
+    throughput = ThroughputMonitor(fabric, window_size=50)
+    step_count = 0
+    total_t0 = time.perf_counter()
+
+    xm.mark_step()
+    for iter_num in range(1, max_iters + 1):
+        if step_count <= warmup_steps:
+            # linear warmup
+            lr = learning_rate * step_count / warmup_steps
+            for param_group in optimizer.param_groups:
+                param_group["lr"] = lr
+
+        iter_t0 = time.perf_counter()
+
+        input_ids, targets = get_batch(fabric, train_data, longest_seq_length)
+
+        is_accumulating = iter_num % gradient_accumulation_iters != 0
+        with fabric.no_backward_sync(model, enabled=is_accumulating):
+            logits = model(input_ids, lm_head_chunk_size=128)
+            xm.mark_step()
+            # 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 / gradient_accumulation_iters)
+        xm.mark_step()
+
+        if not is_accumulating:
+            optimizer.step()
+            optimizer.zero_grad()
+            step_count += 1
+        else:
+            xm.mark_step()
+
+        if iter_num % log_interval == 0:
+            t1 = time.perf_counter()
+            throughput.update(
+                time=t1 - total_t0,
+                batches=iter_num,
+                samples=iter_num * micro_batch_size,
+                lengths=iter_num * micro_batch_size * longest_seq_length,
+                flops=measured_flops * log_interval,
+            )
+            throughput.compute_and_log(step=iter_num)
+            rank_print(
+                fabric,
+                f"iter {iter_num} step {step_count}:"
+                # uncomment to print the loss. this will considerably slow down the iteration times
+                # + f" loss {loss.item():.4f},"
+                + f" iter time: {(t1 - iter_t0) * 1000:.2f}ms"
+                + (" (optimizer.step)" if not is_accumulating else ""),
+            )
+
+        if not is_accumulating and step_count % eval_interval == 0:
+            t0 = time.perf_counter()
+            val_loss = validate(fabric, model, val_data, tokenizer, longest_seq_length)
+            t1 = time.perf_counter() - t0
+            rank_print(fabric, f"step {iter_num}: val loss {val_loss.item():.4f}, val time: {t1 * 1000:.2f}ms")
+            fabric.barrier()
+        if not is_accumulating and step_count % save_interval == 0:
+            checkpoint_path = out_dir / f"iter-{iter_num:06d}-ckpt.pth"
+            save_adapter_checkpoint(fabric, model, checkpoint_path)
+
+
+# xla does not support `inference_mode`: RuntimeError: Cannot set version_counter for inference tensor
+@torch.no_grad()
+def validate(
+    fabric: L.Fabric, model: GPT, val_data: List[Dict], tokenizer: Tokenizer, longest_seq_length: int
+) -> torch.Tensor:
+    rank_print(fabric, "Validating ...")
+    model.eval()
+    losses = torch.zeros(eval_iters)
+    xm.mark_step()
+    for k in range(eval_iters):
+        input_ids, targets = get_batch(fabric, val_data, longest_seq_length)
+        logits = model(input_ids)
+        xm.mark_step()
+        losses[k] = chunked_cross_entropy(logits[..., :-1, :], targets[..., 1:], chunk_size=0)
+    val_loss = losses.mean()
+
+    # produce an example:
+    instruction = "Recommend a movie for me to watch during the weekend and explain the reason."
+    rank_print(fabric, instruction)
+    sample = {"instruction": instruction, "input": ""}
+    prompt = generate_prompt(sample)
+    encoded = tokenizer.encode(prompt, device=fabric.device)
+    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=len(encoded) + eval_max_new_tokens, temperature=0.8)
+    model.clear_kv_cache()
+    output = tokenizer.decode(output)
+    rank_print(fabric, output)
+
+    model.train()
+    return val_loss
+
+
+def get_batch(fabric: L.Fabric, data: List[Dict], longest_seq_length: int) -> Tuple[torch.Tensor, torch.Tensor]:
+    ix = torch.randint(len(data), (micro_batch_size,))
+
+    input_ids = [data[i]["input_ids"].type(torch.int64) for i in ix]
+    labels = [data[i]["labels"].type(torch.int64) for i in ix]
+
+    def pad_right(x, pad_id):
+        # pad right using a fixed longest sequence length to avoid recompilation
+        n = longest_seq_length - len(x)
+        return torch.cat((x, torch.full((n,), pad_id, dtype=x.dtype)))
+
+    x = torch.stack([pad_right(x, pad_id=0) for x in input_ids])
+    y = torch.stack([pad_right(x, pad_id=-1) for x in labels])
+
+    x, y = fabric.to_device((x, y))
+    return x, y
+
+
+def get_longest_seq_length(data: List[Dict]) -> int:
+    # find out the minimum max_seq_length required during fine-tuning (saves memory!)
+    return max(len(d["input_ids"]) for d in data)
+
+
+def save_adapter_checkpoint(fabric: L.Fabric, model: torch.nn.Module, file_path: Path) -> None:
+    rank_print(fabric, f"Saving adapter weights to {str(file_path)!r}")
+    fabric.save(file_path, {"model": model}, filter={"model": adapter_filter})
+
+
+if __name__ == "__main__":
+    from jsonargparse import CLI
+
+    CLI(setup)

extensions/xla/generate/adapter.py

@@ -0,0 +1,133 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+import lightning as L
+from lightning.fabric.accelerators import XLAAccelerator
+from lightning.fabric.strategies import XLAFSDPStrategy
+
+from litgpt import Tokenizer
+from litgpt.adapter import GPT, Block, Config
+from litgpt.prompts import Alpaca
+from litgpt.utils import check_valid_checkpoint_dir, lazy_load
+
+# support running without installing as a package
+wd = Path(__file__).parents[3].resolve()
+sys.path.append(str(wd))
+
+from xla.generate.base import generate  # noqa: E402
+from xla.utils import rank_print  # noqa: E402
+
+
+def setup(
+    prompt: str = "What food do llamas eat?",
+    *,
+    input: str = "",
+    sys_prompt: Optional[str] = None,
+    adapter_path: Path = Path("out/adapter/alpaca/lit_model_adapter_finetuned.pth"),
+    checkpoint_dir: Path = Path("checkpoints/tiiuae/falcon-7b"),
+    max_new_tokens: int = 100,
+    top_k: Optional[int] = 50,
+    temperature: float = 0.8,
+    precision: str = "bf16-true",
+) -> None:
+    """Generates a response based on a given instruction and an optional input.
+    This script will only work with checkpoints from the instruction-tuned Adapter model.
+    See `xla/finetune/adapter.py`.
+
+    Args:
+        prompt: The prompt/instruction (Alpaca style).
+        input: Optional input (Alpaca style).
+        sys_prompt: Optional system prompt.
+        adapter_path: Path to the checkpoint with trained adapter weights, which are the output of
+            `xla/finetune/adapter.py`.
+        checkpoint_dir: The path to the checkpoint folder with pretrained model weights.
+        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.
+        temperature: A value controlling the randomness of the sampling process. Higher values result in more random
+            samples.
+        precision: Indicates the Fabric precision setting to use.
+    """
+    devices = XLAAccelerator.auto_device_count()
+    strategy = XLAFSDPStrategy(auto_wrap_policy={Block}) if devices > 1 else "auto"
+    fabric = L.Fabric(devices=devices, precision=precision, strategy=strategy)
+    fabric.launch(main, prompt, input, sys_prompt, adapter_path, checkpoint_dir, max_new_tokens, top_k, temperature)
+
+
+def main(
+    fabric: L.Fabric,
+    prompt: str,
+    input: str,
+    sys_prompt: Optional[str],
+    adapter_path: Path,
+    checkpoint_dir: Path,
+    max_new_tokens: int,
+    top_k: Optional[int],
+    temperature: float,
+) -> None:
+    check_valid_checkpoint_dir(checkpoint_dir)
+
+    config = Config.from_file(checkpoint_dir / "model_config.yaml", adapter_start_layer=0)
+
+    checkpoint_path = checkpoint_dir / "lit_model.pth"
+
+    rank_print(fabric, f"Loading model {str(checkpoint_path)!r} with {config.__dict__}", file=sys.stderr)
+    t0 = time.perf_counter()
+    with fabric.init_module(empty_init=True):
+        model = GPT(config)
+    rank_print(fabric, f"Time to instantiate model: {time.perf_counter() - t0:.02f} seconds.", file=sys.stderr)
+
+    t0 = time.perf_counter()
+    checkpoint = lazy_load(checkpoint_path)
+    adapter_checkpoint = lazy_load(adapter_path)
+    checkpoint.update(adapter_checkpoint.get("model", adapter_checkpoint))
+    model.load_state_dict(checkpoint)
+    rank_print(fabric, f"Time to load the model weights: {time.perf_counter() - t0:.02f} seconds.", file=sys.stderr)
+
+    model.eval()
+    model = fabric.setup_module(model)
+
+    tokenizer = Tokenizer(checkpoint_dir)
+    # TODO: Load prompt style from checkpoint and apply it here
+    prompt_style = Alpaca()
+    prompt = prompt_style.apply(prompt, sys_prompt=sys_prompt, input=input)
+    encoded = tokenizer.encode(prompt, device=fabric.device)
+    prompt_length = encoded.size(0)
+    max_returned_tokens = prompt_length + max_new_tokens
+
+    with fabric.init_tensor():
+        # set the max_seq_length to limit the memory usage to what we need
+        model.max_seq_length = max_returned_tokens
+        # enable the kv cache
+        model.set_kv_cache(batch_size=1)
+
+    t0 = time.perf_counter()
+    y = generate(
+        model,
+        encoded,
+        max_returned_tokens,
+        max_seq_length=max_returned_tokens,
+        temperature=temperature,
+        top_k=top_k,
+        eos_id=tokenizer.eos_id,
+    )
+    t = time.perf_counter() - t0
+
+    output = tokenizer.decode(y)
+    output = output.split("### Response:")[1] if "### Response:" in output else output
+    output = output.strip()
+    fabric.print(output)
+
+    tokens_generated = y.size(0) - prompt_length
+    rank_print(
+        fabric, f"\n\nTime for inference: {t:.02f} sec total, {tokens_generated / t:.02f} tokens/sec", file=sys.stderr
+    )
+
+
+if __name__ == "__main__":
+    from jsonargparse import CLI
+
+    CLI(setup)

extensions/xla/generate/base.py

@@ -0,0 +1,185 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+import lightning as L
+import torch
+import torch_xla.core.xla_model as xm
+from lightning.fabric.accelerators import XLAAccelerator
+from lightning.fabric.strategies import XLAFSDPStrategy
+
+from litgpt import GPT, Config, Tokenizer
+from litgpt.model import Block
+from litgpt.utils import check_valid_checkpoint_dir, lazy_load
+
+# support running without installing as a package
+wd = Path(__file__).parents[3].resolve()
+sys.path.append(str(wd))
+
+from xla.utils import rank_print  # noqa: E402
+
+
+# xla does not support `inference_mode`: RuntimeError: Cannot set version_counter for inference tensor
+@torch.no_grad()
+def generate(
+    model: GPT,
+    idx: torch.Tensor,
+    max_returned_tokens: int,
+    *,
+    temperature: float = 1.0,
+    top_k: Optional[int] = None,
+    eos_id: Optional[int] = None,
+) -> torch.Tensor:
+    """Takes a conditioning sequence (prompt) as input and continues to generate as many tokens as requested.
+
+    The implementation of this function is modified from A. Karpathy's nanoGPT.
+
+    Args:
+        model: The model to use.
+        idx: 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.
+        eos_id: If specified, stop generating any more token once the <eos> token is triggered.
+    """
+    T = idx.size(0)
+    assert max_returned_tokens > T
+    if model.max_seq_length < max_returned_tokens - 1:
+        # rolling the kv cache based on the `input_pos` value would be necessary. However, doing so would introduce a
+        # data dependency on the `input_pos` tensor and impact model compilation. Since this setting is uncommon, we do
+        # not support it to avoid negatively impacting the overall speed
+        raise NotImplementedError(f"max_seq_length {model.max_seq_length} needs to be >= {max_returned_tokens - 1}")
+
+    device, dtype = idx.device, idx.dtype
+    # create an empty tensor of the expected final shape and fill in the current tokens
+    empty = torch.empty(max_returned_tokens, dtype=dtype, device=device)
+    empty[:T] = idx
+    idx = empty
+    # TODO: FSDP has an internal broadcasting issue, so we are forced to have this be of length 1 until it's fixed
+    input_pos = torch.tensor([0], device=device)
+
+    xm.mark_step()
+
+    # generate up to a fixed number of tokens
+    for _ in range(max_returned_tokens):
+        x = idx.index_select(0, input_pos).view(1, -1)
+
+        # forward
+        logits = model(x, input_pos)
+        logits = logits[0, -1] / temperature
+
+        # optionally crop the logits to only the top k options
+        if top_k is not None:
+            v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+            logits = torch.where(logits < v[[-1]], -float("Inf"), logits)
+
+        probs = torch.nn.functional.softmax(logits, dim=-1)
+        idx_next = torch.multinomial(probs, num_samples=1).to(dtype=dtype)
+
+        # advance
+        input_pos = input_pos[-1:] + 1
+
+        xm.mark_step()
+
+        # concatenate the new generation
+        idx = idx.index_copy(0, input_pos, idx_next)
+
+        # if <eos> token is triggered, return the output (stop generation)
+        if idx_next == eos_id:
+            return idx[:input_pos]  # include the EOS token
+
+    return idx
+
+
+def setup(
+    prompt: str = "What food do llamas eat?",
+    *,
+    num_samples: int = 1,
+    max_new_tokens: int = 100,
+    top_k: Optional[int] = 50,
+    temperature: float = 0.8,
+    checkpoint_dir: Path = Path("checkpoints/tiiuae/falcon-7b"),
+    precision: str = "bf16-true",
+) -> None:
+    """Generates text samples based on a pre-trained model and tokenizer.
+
+    Args:
+        prompt: The prompt string to use for generating the samples.
+        num_samples: The number of text samples to generate.
+        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.
+        temperature: A value controlling the randomness of the sampling process. Higher values result in more random
+            samples.
+        checkpoint_dir: The checkpoint directory to load.
+        precision: Indicates the Fabric precision setting to use.
+    """
+    devices = XLAAccelerator.auto_device_count()
+    strategy = XLAFSDPStrategy(auto_wrap_policy={Block}) if devices > 1 else "auto"
+    fabric = L.Fabric(devices=devices, precision=precision, strategy=strategy)
+    fabric.launch(main, prompt, num_samples, max_new_tokens, top_k, temperature, checkpoint_dir)
+
+
+def main(
+    fabric: L.Fabric,
+    prompt: str,
+    num_samples: int,
+    max_new_tokens: int,
+    top_k: Optional[int],
+    temperature: float,
+    checkpoint_dir: Path,
+) -> None:
+    check_valid_checkpoint_dir(checkpoint_dir)
+
+    config = Config.from_file(checkpoint_dir / "model_config.yaml")
+
+    checkpoint_path = checkpoint_dir / "lit_model.pth"
+
+    rank_print(fabric, f"Loading model {str(checkpoint_path)!r} with {config.__dict__}", file=sys.stderr)
+    t0 = time.perf_counter()
+    with fabric.init_module(empty_init=True):
+        model = GPT(config)
+    rank_print(fabric, f"Time to instantiate model: {time.perf_counter() - t0:.02f} seconds.", file=sys.stderr)
+
+    t0 = time.perf_counter()
+    checkpoint = lazy_load(checkpoint_path)
+    model.load_state_dict(checkpoint.get("model", checkpoint))
+    rank_print(fabric, f"Time to load the model weights: {time.perf_counter() - t0:.02f} seconds.", file=sys.stderr)
+
+    model.eval()
+    model = fabric.setup_module(model)
+
+    tokenizer = Tokenizer(checkpoint_dir)
+    encoded = tokenizer.encode(prompt, device=fabric.device)
+    prompt_length = encoded.size(0)
+    max_returned_tokens = prompt_length + max_new_tokens
+
+    with fabric.init_tensor():
+        # set the max_seq_length to limit the memory usage to what we need
+        model.max_seq_length = max_returned_tokens
+
+    L.seed_everything(1234)
+    for i in range(num_samples):
+        with fabric.init_tensor():
+            # enable the kv cache
+            model.set_kv_cache(batch_size=1)
+
+        t0 = time.perf_counter()
+        y = generate(model, encoded, max_returned_tokens, temperature=temperature, top_k=top_k)
+        t = time.perf_counter() - t0
+
+        fabric.print(tokenizer.decode(y))
+        tokens_generated = y.size(0) - prompt_length
+        rank_print(
+            fabric,
+            f"Time for inference {i + 1}: {t:.02f} sec total, {tokens_generated / t:.02f} tokens/sec",
+            file=sys.stderr,
+        )
+
+
+if __name__ == "__main__":
+    from jsonargparse import CLI
+
+    CLI(setup)

extensions/xla/scripts/prepare_alpaca.py

@@ -0,0 +1,147 @@
+# 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 pathlib import Path
+from typing import Optional
+
+import torch
+import yaml
+from lightning_utilities.core.imports import RequirementCache
+from torch.utils.data import random_split
+from tqdm import tqdm
+
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import CLI
+
+
+def prepare(
+    destination_path: Path = Path("data/alpaca"),
+    checkpoint_dir: Path = Path("checkpoints/stabilityai/stablelm-base-alpha-3b"),
+    val_split_fraction: float = 0.03865,  # to get exactly 2000 validation samples,
+    seed: int = 42,
+    mask_inputs: bool = False,  # as in alpaca-lora
+    data_file_name: str = "alpaca_data_cleaned_archive.json",
+    data_file_url: str = "https://raw.githubusercontent.com/tloen/alpaca-lora/main/alpaca_data_cleaned_archive.json",
+    ignore_index: int = -100,
+    max_seq_length: Optional[int] = None,
+) -> None:
+    """Prepare the Alpaca dataset for instruction tuning.
+
+    The output is a training and test dataset saved as `train.pt` and `test.pt`,
+    which stores the preprocessed and tokenized prompts and labels.
+    """
+    if max_seq_length is None:
+        with open(checkpoint_dir / "model_config.yaml", encoding="utf-8") as file:
+            config = yaml.safe_load(file)
+            max_seq_length = config["block_size"]
+
+    destination_path.mkdir(parents=True, exist_ok=True)
+    data_file_path = destination_path / data_file_name
+    print("Loading data file...")
+    download_if_missing(data_file_path, data_file_url)
+    with open(data_file_path, encoding="utf-8") as file:
+        data = json.load(file)
+
+    print("Loading tokenizer...")
+    tokenizer = Tokenizer(checkpoint_dir)
+
+    # Partition the dataset into train and test
+    train_set, test_set = random_split(
+        data, [1.0 - val_split_fraction, val_split_fraction], generator=torch.Generator().manual_seed(seed)
+    )
+    train_set, test_set = list(train_set), list(test_set)
+
+    print(f"train has {len(train_set):,} samples")
+    print(f"test has {len(test_set):,} samples")
+
+    print("Processing train split ...")
+    train_set = [
+        prepare_sample(
+            example=sample,
+            tokenizer=tokenizer,
+            max_length=max_seq_length,
+            mask_inputs=mask_inputs,
+            ignore_index=ignore_index,
+        )
+        for sample in tqdm(train_set)
+    ]
+    torch.save(train_set, destination_path / "train.pt")
+
+    print("Processing test split ...")
+    test_set = [
+        prepare_sample(
+            example=sample,
+            tokenizer=tokenizer,
+            max_length=max_seq_length,
+            mask_inputs=mask_inputs,
+            ignore_index=ignore_index,
+        )
+        for sample in tqdm(test_set)
+    ]
+    torch.save(test_set, destination_path / "test.pt")
+
+
+def download_if_missing(file_path: Path, file_url: str) -> 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
+
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(requests.get(file_url).text)
+
+
+def prepare_sample(example: dict, tokenizer: Tokenizer, max_length: int, mask_inputs: bool, ignore_index: int) -> dict:
+    """Processes a single sample.
+
+    Each sample in the dataset consists of:
+    - instruction: A string describing the task
+    - input: A string holding a special input value for the instruction.
+        This only applies to some samples, and in others this is empty.
+    - output: The response string
+
+    This function processes this data to produce a prompt text and a label for
+    supervised training. The prompt text is formed as a single message including both
+    the instruction and the input. The label/target is the same message but with the
+    response attached.
+
+    Finally, both the prompt and the label get tokenized. If desired, all tokens
+    in the label that correspond to the original input prompt get masked out (default).
+    """
+    full_prompt = generate_prompt(example)
+    full_prompt_and_response = full_prompt + example["output"]
+    encoded_full_prompt = tokenizer.encode(full_prompt, max_length=max_length)
+    encoded_full_prompt_and_response = tokenizer.encode(full_prompt_and_response, eos=True, max_length=max_length)
+
+    # The labels are the full prompt with response, but with the prompt masked out
+    labels = encoded_full_prompt_and_response.clone()
+    if mask_inputs:
+        labels[: len(encoded_full_prompt)] = ignore_index
+
+    return {**example, "input_ids": encoded_full_prompt_and_response, "labels": labels}
+
+
+def generate_prompt(example: dict) -> str:
+    """Generates a standardized message to prompt the model with an instruction, optional input and a
+    'response' field."""
+
+    if example["input"]:
+        return (
+            "Below is an instruction that describes a task, paired with an input that provides further context. "
+            "Write a response that appropriately completes the request.\n\n"
+            f"### Instruction:\n{example['instruction']}\n\n### Input:\n{example['input']}\n\n### Response:"
+        )
+    return (
+        "Below is an instruction that describes a task. "
+        "Write a response that appropriately completes the request.\n\n"
+        f"### Instruction:\n{example['instruction']}\n\n### Response:"
+    )
+
+
+if __name__ == "__main__":
+    CLI(prepare)

out/eval/tinyllama_benches/2407_full/results.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5730d224018003dc11b022be88294d8826441e2f520627b68ea575a253d78f2
+size 141666967

out/eval/tinyllama_benches/2407_full/tokenizer.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e556afd44213b6bd1be2b850ebbbd98f5481437a8021afaf58ee7fb1818d347
+size 499723

out/eval/tinyllama_benches/2408_full/results.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af531a9213c59c2c565778508b581b66671c8cf39b77fdaab7d0360dab23364e
+size 141669063