Add files using upload-large-folder tool

.azure/gpu-test.yml

@@ -0,0 +1,114 @@
+name: GPU tests
+
+trigger:
+  branches:
+    include:
+      - "main"
+      - "wip"
+
+pr:
+  branches:
+    include:
+      - "main"
+      - "wip"
+
+jobs:
+  - job: testing
+    strategy:
+      matrix:
+        "ordinary":
+          #image: "pytorchlightning/pytorch_lightning:base-cuda-py3.10-torch2.7-cuda12.6.3"
+          dependency: ""
+        "w. Thunder":
+          #image: "pytorchlightning/pytorch_lightning:base-cuda-py3.10-torch2.7-cuda12.6.3"
+          dependency: "compiler"
+    variables:
+      DEVICES: $( python -c 'print("$(Agent.Name)".split("_")[-1])' )
+      RUN_ONLY_CUDA_TESTS: "1"
+      TRANSFORMERS_CACHE: "/var/tmp/hf/transformers"
+      HF_HOME: "/var/tmp/hf/home"
+      HF_HUB_CACHE: "/var/tmp/hf/hub"
+      SKIP_WITH_CI: "1"
+      NCCL_DEBUG: "INFO"
+      PYTHON_VERSION: "3.10"
+      CUDA_VERSION: "12.6.3"
+      TORCH_VERSION: "2.7.1"
+      CUDNN_FRONTEND_VERSION: "1.10.0"
+    container:
+      # image: "pytorchlightning/pytorch_lightning:base-cuda-py$(PYTHON_VERSION)-torch$(TORCH_VERSION)-cuda$(CUDA_VERSION)"
+      # pytorchlightning/lightning-thunder:ubuntu22.04-cuda12.1.1-cudnn-fe1.5.0-py3.10-pt_main-dev
+      image: "pytorchlightning/lightning-thunder:ubuntu24.04-cuda$(CUDA_VERSION)-cudnn-fe$(CUDNN_FRONTEND_VERSION)-py$(PYTHON_VERSION)-pt_$(TORCH_VERSION)-dev"
+      options: "--gpus=all --shm-size=8gb -v /var/tmp:/var/tmp"
+    workspace:
+      clean: all
+    pool: "lit-rtx-3090"
+    timeoutInMinutes: "35"
+    cancelTimeoutInMinutes: "2"
+    steps:
+      - bash: |
+          echo "##vso[task.setvariable variable=CUDA_VISIBLE_DEVICES]$(DEVICES)"
+        displayName: "set env. vars"
+
+      - bash: |
+          echo $(DEVICES)
+          echo $CUDA_VISIBLE_DEVICES
+          dpkg-query -W -f='${Package} ${Version}\n' libnccl2 libnccl-dev
+          whereis nvidia
+          nvidia-smi
+          which python && which pip
+          python --version
+          pip --version
+          pip list
+        displayName: "Image info & NVIDIA"
+
+      - script: |
+          pip install --upgrade pip
+          pip install '.[extra,test]' "torch==${TORCH_VERSION}" cffi -U
+        displayName: "Install package & dependencies"
+
+      - script: |
+          set -e
+          pip uninstall -y torchvision torchaudio
+          pip install '.[compiler,extra,test]' "torch==${TORCH_VERSION}"
+          python -c "from thunder.executors import nvfuser_available ; assert nvfuser_available(), 'nvFuser is missing!'"
+          python -c "from thunder.executors.triton_utils import triton_version ; assert triton_version() is not None, 'triton is missing!'"
+        condition: eq(variables['dependency'], 'compiler')
+        displayName: "Install `compiler` [nvFuser & Thunder]"
+
+      - bash: |
+          set -e
+          pip list
+          python -c "import torch ; mgpu = torch.cuda.device_count() ; assert mgpu == 2, f'GPU: {mgpu}'"
+          python -c "from torch import __version__ as ver ; assert str(ver).split('+')[0] == '$(TORCH_VERSION)', f'PyTorch: installed {ver} but expected $(TORCH_VERSION)'"
+        displayName: "Env details"
+
+      - bash: pytest -v --durations=100
+        displayName: "All tests"
+        timeoutInMinutes: "15"
+
+      - bash: |
+          wget https://raw.githubusercontent.com/Lightning-AI/utilities/main/scripts/run_standalone_tests.sh
+          bash run_standalone_tests.sh "tests"
+        displayName: "Standalone tests"
+        env:
+          PL_RUN_STANDALONE_TESTS: "1"
+          # NUM_PARALLEL_TESTS: "10"
+          NCCL_IGNORE_DISABLED_P2P: "1"
+          NCCL_DEBUG: "INFO"
+        timeoutInMinutes: "10"
+
+      - bash: |
+          pip uninstall -y lightning-thunder
+          # install thunder from source, so that, thunder.tests will be available
+          pip install -U "lightning-thunder[test] @ git+https://github.com/Lightning-AI/lightning-thunder.git" "torch==${TORCH_VERSION}"
+        displayName: "Re-install Thunder [main branch]"
+        condition: eq(variables['dependency'], 'compiler')
+
+      - bash: |
+          # without env var, it filters out all tests
+          RUN_ONLY_CUDA_TESTS=0 pytest tests/ext_thunder/test_thunder_networks.py -v --durations=50
+        displayName: "Extra tests for Thunder [main branch]"
+        condition: eq(variables['dependency'], 'compiler')
+        env:
+          TORCHDYNAMO_VERBOSE: "1"
+        timeoutInMinutes: "10"

.devcontainer/Dockerfile

@@ -0,0 +1,9 @@
+# See here for image contents: https://github.com/devcontainers/images/blob/main/src/python/.devcontainer/Dockerfile
+
+# [Choice] Python version (use -bookworm or -bullseye variants on local arm64/Apple Silicon): 3, 3.12, 3.11, 3.10, 3.9, 3.8, 3-bookworm, 3.12-bookworm, 3.11-bookworm, 3.10-bookworm, 3.9-bookworm, 3.8-bookworm, 3-bullseye, 3.12-bullseye, 3.11-bullseye, 3.10-bullseye, 3.9-bullseye, 3.8-bullseye, 3-buster, 3.12-buster, 3.11-buster, 3.10-buster, 3.9-buster, 3.8-buster
+ARG VARIANT=3-bookworm
+FROM mcr.microsoft.com/devcontainers/python:1-${VARIANT}
+
+# Temporary: Upgrade python packages due to https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-40897
+# They are installed by the base image (python) which does not have the patch.
+RUN python3 -m pip install --upgrade pip setuptools

.devcontainer/devcontainer.json

@@ -0,0 +1,105 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.194.0/containers/python-3
+{
+  "name": "Python 3 (litgpt)",
+  "build": {
+    "dockerfile": "Dockerfile",
+    "context": "..",
+    "args": {
+      "VARIANT": "3.11-bookworm"
+    }
+  },
+  "runArgs": [
+    // Enable GPU passthrough, requires WSL2 on Windows
+    //"--gpus=all",
+    // One of the following options is required for torch multiprocessing
+    //"--ipc=host",
+    //"--shm-size=4gb",
+  ],
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  "features": {
+    "ghcr.io/devcontainers/features/git:1": {},
+    "ghcr.io/devcontainers/features/git-lfs:1": {},
+    //"ghcr.io/devcontainers/features/nvidia-cuda:1": {},
+    "ghcr.io/devcontainers-extra/features/actionlint:1": {},
+    "ghcr.io/devcontainers-extra/features/pre-commit:2": {},
+    "ghcr.io/dhoeric/features/act:1": {},
+    "ghcr.io/devcontainers/features/docker-in-docker:2": {
+      "version": "latest",
+      "moby": true
+    }
+  },
+  // Set *default* container specific settings.json values on container create.
+  "customizations": {
+    "vscode": {
+      "settings": {
+        "editor.tabSize": 4,
+        "editor.renderWhitespace": "all",
+        "editor.formatOnSave": true,
+        "editor.rulers": [120],
+        "files.exclude": {
+          "**/__pycache__": true
+        },
+        "python.pythonPath": "/usr/local/bin/python",
+        "python.defaultInterpreterPath": "/usr/local/bin/python",
+        "python.languageServer": "Pylance",
+        "python.analysis.autoImportCompletions": true,
+        "python.analysis.completeFunctionParens": true,
+        "python.analysis.autoSearchPaths": true,
+        "python.testing.pytestArgs": ["tests"],
+        "python.testing.unittestEnabled": false,
+        "python.testing.pytestEnabled": true,
+        "code-eol.highlightNonDefault": true,
+        "code-eol.highlightExtraWhitespace": true,
+        "autoDocstring.docstringFormat": "google-notypes",
+        "autoDocstring.guessTypes": true,
+        "autoDocstring.generateDocstringOnEnter": true,
+        "autoDocstring.startOnNewLine": true,
+        "telemetry.telemetryLevel": "off",
+        "[python]": {
+          "editor.formatOnSave": true,
+          "editor.defaultFormatter": "charliermarsh.ruff",
+          "editor.codeActionsOnSave": {
+            "source.organizeImports": "always",
+            "source.fixAll": "always"
+          }
+        }
+      },
+      // Add the IDs of extensions you want installed when the container is created.
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "ms-toolsai.jupyter",
+        "GitHub.copilot",
+        "GitHub.copilot-chat",
+        "github.vscode-github-actions",
+        "SanjulaGanepola.github-local-actions",
+        "charliermarsh.ruff",
+        "esbenp.prettier-vscode",
+        "ms-vscode.test-adapter-converter",
+        "njqdev.vscode-python-typehint",
+        "KevinRose.vsc-python-indent",
+        "medo64.render-crlf",
+        "shardulm94.trailing-spaces",
+        "nhoizey.gremlins",
+        "wayou.vscode-todo-highlight",
+        "Gruntfuggly.todo-tree",
+        "njpwerner.autodocstring",
+        "rodolphebarbanneau.python-docstring-highlighter",
+        "mechatroner.rainbow-csv",
+        "uctakeoff.vscode-counter",
+        "bierner.github-markdown-preview",
+        "yahyabatulu.vscode-markdown-alert",
+        "ms-vscode-remote.vscode-remote-extensionpack",
+        "ms-azuretools.vscode-docker",
+        "redhat.vscode-yaml"
+      ]
+    }
+  },
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+  // Use 'postCreateCommand' to run commands after the container is created.
+  "postCreateCommand": "pre-commit install && pip install '.[extra,compiler,test]' -U",
+  // Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+  "remoteUser": "vscode"
+}

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+* @lantiga @t-vi @borda
+/README.md                           @williamfalcon @lantiga

.github/dependabot.yml

@@ -0,0 +1,41 @@
+# Basic dependabot.yml file with
+# minimum configuration for two package managers
+
+version: 2
+updates:
+  # Enable version updates for python
+  - package-ecosystem: "pip"
+    # Look for a `requirements` in the `root` directory
+    directory: "/"
+    # Check for updates once a week
+    schedule:
+      interval: "monthly"
+    # Labels on pull requests for version updates only
+    labels:
+      - "dependencies"
+    pull-request-branch-name:
+      # Separate sections of the branch name with a hyphen
+      # for example, `dependabot-npm_and_yarn-next_js-acorn-6.4.1`
+      separator: "-"
+    # Allow up to 5 open pull requests for pip dependencies
+    open-pull-requests-limit: 3
+
+  # Enable version updates for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    # Check for updates once a week
+    schedule:
+      interval: "weekly"
+    # Labels on pull requests for version updates only
+    labels:
+      - "CI / actions"
+    pull-request-branch-name:
+      # Separate sections of the branch name with a hyphen
+      # for example, `dependabot-npm_and_yarn-next_js-acorn-6.4.1`
+      separator: "-"
+    # Allow up to 5 open pull requests for GitHub Actions
+    open-pull-requests-limit: 1
+    groups:
+      GHA-updates:
+        patterns:
+          - "*"

.gitignore

@@ -0,0 +1,24 @@
+.ipynb_checkpoints/
+__pycache__
+.idea
+.DS_Store
+*.egg-info
+build
+dist
+.venv
+.vscode
+
+# data
+data
+datasets
+!litgpt/data
+!tests/data
+checkpoints
+out
+wandb
+events.out.tfevents*
+
+# test artifacts from tests/test_readme.py
+**/custom_finetuning_dataset.json
+client.py
+**/custom_texts/

.pre-commit-config.yaml

@@ -0,0 +1,89 @@
+# Copyright The Lightning team.
+#
+# 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.
+
+default_language_version:
+  python: python3
+
+ci:
+  autofix_prs: true
+  autoupdate_commit_msg: "[pre-commit.ci] pre-commit suggestions"
+  autoupdate_schedule: quarterly
+  # submodules: true
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+        exclude: README.md
+      - id: check-yaml
+      - id: check-toml
+      #- id: check-docstring-first
+      #- id: check-executables-have-shebangs
+      - id: check-case-conflict
+      - id: check-added-large-files
+        args: ["--maxkb=250", "--enforce-all"]
+      - id: detect-private-key
+
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.4.1
+    hooks:
+      - id: codespell
+        additional_dependencies: [tomli]
+        args: ["--write-changes"]
+        exclude: pyproject.toml
+
+  #- repo: https://github.com/crate-ci/typos
+  #  rev: dictgen-v0.3.1
+  #  hooks:
+  #    - id: typos
+  #      args: [] # empty to do not write fixes
+  #      exclude: pyproject.toml
+
+  #- repo: https://github.com/executablebooks/mdformat
+  #  rev: 0.7.21
+  #  hooks:
+  #    - id: mdformat
+  #      args: ["--number"]
+  #      additional_dependencies:
+  #        - mdformat-gfm
+  #        - mdformat-black
+  #        - mdformat_frontmatter
+
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v3.1.0
+    hooks:
+      - id: prettier
+        files: \.(json|yml|yaml|toml)
+        # https://prettier.io/docs/en/options.html#print-width
+        args: ["--print-width=140"]
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.2
+    hooks:
+      - id: ruff
+        args: ["--fix"]
+      - id: ruff-format
+      - id: ruff
+
+  - repo: https://github.com/tox-dev/pyproject-fmt
+    rev: v2.6.0
+    hooks:
+      - id: pyproject-fmt
+        additional_dependencies: [tox]
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.24.1
+    hooks:
+      - id: validate-pyproject

CITATION.cff

@@ -0,0 +1,9 @@
+cff-version: 1.2.0
+message: "If you use this software, you can cite it as shown below."
+title: "LitGPT"
+abstract: "20+ high-performance LLMs with recipes to pretrain, finetune and deploy at scale."
+date-released: 2023-03-22
+authors:
+  - name: "The Lightning AI team"
+license: "Apache-2.0"
+url: "https://github.com/Lightning-AI/litgpt"

Dockerfile

@@ -0,0 +1,17 @@
+FROM ubuntu:22.04
+
+# 设置 UTF-8（重要，否则 python/其他程序可能乱码）
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+
+# 安装常用工具（可选）
+RUN apt-get update && apt-get install -y \
+    python3 python3-pip vim git wget curl \
+    && apt-get clean
+
+# 把你的整个文件夹复制进镜像
+COPY . /workspace
+
+# 设置默认工作目录
+WORKDIR /workspace
+

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2023] Lightning AI
+
+   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.

README.md

@@ -1,3 +1,722 @@
----
-license: mit
----
+<div align="center">
+
+
+# ⚡ LitGPT
+
+**20+ high-performance LLMs with recipes to pretrain, finetune, and deploy at scale.**
+
+<pre>
+✅ From scratch implementations      ✅ No abstractions         ✅ Beginner friendly
+   ✅ Flash attention                   ✅ FSDP                    ✅ LoRA, QLoRA, Adapter
+✅ Reduce GPU memory (fp4/8/16/32)   ✅ 1-1000+ GPUs/TPUs       ✅ 20+ LLMs         
+</pre>
+
+
+---
+
+
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytorch-lightning)
+![cpu-tests](https://github.com/lightning-AI/lit-stablelm/actions/workflows/cpu-tests.yml/badge.svg) [![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/Lightning-AI/lit-stablelm/blob/master/LICENSE) [![Discord](https://img.shields.io/discord/1077906959069626439)](https://discord.gg/VptPCZkGNa)
+
+<p align="center">
+  <a href="#quick-start">Quick start</a> •
+  <a href="#choose-from-20-llms">Models</a> •
+  <a href="#finetune-an-llm">Finetune</a> •
+  <a href="#deploy-an-llm">Deploy</a> •
+  <a href="#all-workflows">All workflows</a> •
+  <a href="#state-of-the-art-features">Features</a> •
+  <a href="#training-recipes">Recipes (YAML)</a> •
+  <a href="https://lightning.ai/">Lightning AI</a> •
+    <a href="#tutorials">Tutorials</a>
+</p>
+
+&nbsp;
+
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-quick-start">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/get-started-badge.svg" height="36px" alt="Get started"/>
+</a>
+
+&nbsp;
+
+</div>
+
+# Use, finetune, pretrain, and deploy LLMs Lightning fast ⚡⚡
+Every LLM is implemented from scratch with **no abstractions** and **full control**, making them blazing fast, minimal, and performant at enterprise scale.
+
+✅ **Enterprise ready -** Apache 2.0 for unlimited enterprise use.</br>
+✅ **Developer friendly -** Easy debugging with no abstraction layers and single file implementations.</br>
+✅ **Optimized performance -** Models designed to maximize performance, reduce costs, and speed up training.</br>
+✅ **Proven recipes -** Highly-optimized training/finetuning recipes tested at enterprise scale.</br>
+
+&nbsp;
+
+# Quick start
+Install LitGPT
+```
+pip install 'litgpt[extra]'
+```
+
+Load and use any of the [20+ LLMs](#choose-from-20-llms):
+```python
+from litgpt import LLM
+
+llm = LLM.load("microsoft/phi-2")
+text = llm.generate("Fix the spelling: Every fall, the family goes to the mountains.")
+print(text)
+# Corrected Sentence: Every fall, the family goes to the mountains.
+```
+
+&nbsp;
+
+✅ Optimized for fast inference</br>
+✅ Quantization</br>
+✅ Runs on low-memory GPUs</br>
+✅ No layers of internal abstractions</br>
+✅ Optimized for production scale</br>
+
+<details>
+  <summary>Advanced install options</summary>
+
+Install from source:
+
+```bash
+git clone https://github.com/Lightning-AI/litgpt
+cd litgpt
+pip install -e '.[all]'
+```
+</details>
+
+[Explore the full Python API docs](tutorials/python-api.md).
+
+&nbsp;
+
+---
+# Choose from 20+ LLMs
+Every model is written from scratch to maximize performance and remove layers of abstraction:
+
+| Model | Model size | Author | Reference |
+|----|----|----|----|
+| Llama 3, 3.1, 3.2, 3.3 | 1B, 3B, 8B, 70B, 405B | Meta AI | [Meta AI 2024](https://github.com/meta-llama/llama3)                                           |
+| Code Llama | 7B, 13B, 34B, 70B | Meta AI | [Rozière et al. 2023](https://arxiv.org/abs/2308.12950)                                       |
+| CodeGemma | 7B | Google | [Google Team, Google Deepmind](https://ai.google.dev/gemma/docs/codegemma)                                     |
+| Gemma 2 | 2B, 9B, 27B | Google | [Google Team, Google Deepmind](https://storage.googleapis.com/deepmind-media/gemma/gemma-2-report.pdf)  |
+| Phi 4 | 14B | Microsoft Research | [Abdin et al. 2024](https://arxiv.org/abs/2412.08905)                                                                            |
+| Qwen2.5 | 0.5B, 1.5B, 3B, 7B, 14B, 32B, 72B | Alibaba Group | [Qwen Team 2024](https://qwenlm.github.io/blog/qwen2.5/)                                               |
+| Qwen2.5 Coder | 0.5B, 1.5B, 3B, 7B, 14B, 32B | Alibaba Group | [Hui, Binyuan et al. 2024](https://arxiv.org/abs/2409.12186)                                          |
+| R1 Distill Llama | 8B, 70B | DeepSeek AI | [DeepSeek AI 2025](https://github.com/deepseek-ai/DeepSeek-R1/blob/main/DeepSeek_R1.pdf)                                                                                 |
+| ... | ... | ... | ...   |
+
+<details>
+  <summary>See full list of 20+ LLMs</summary>
+
+&nbsp;
+
+#### All models
+
+| Model | Model size | Author | Reference |
+|----|----|----|----|
+| CodeGemma | 7B | Google | [Google Team, Google Deepmind](https://ai.google.dev/gemma/docs/codegemma)                                                                 |
+| Code Llama | 7B, 13B, 34B, 70B | Meta AI | [Rozière et al. 2023](https://arxiv.org/abs/2308.12950)                                                                   |
+| Falcon | 7B, 40B, 180B | TII UAE | [TII 2023](https://falconllm.tii.ae)                                                                                              |
+| Falcon 3 | 1B, 3B, 7B, 10B | TII UAE | [TII 2024](https://huggingface.co/blog/falcon3)                                                                                              |
+| FreeWilly2 (Stable Beluga 2) | 70B | Stability AI | [Stability AI 2023](https://stability.ai/blog/stable-beluga-large-instruction-fine-tuned-models)                 |
+| Function Calling Llama 2 | 7B | Trelis | [Trelis et al. 2023](https://huggingface.co/Trelis/Llama-2-7b-chat-hf-function-calling-v2)                                  |
+| Gemma | 2B, 7B | Google | [Google Team, Google Deepmind](https://storage.googleapis.com/deepmind-media/gemma/gemma-report.pdf)                                       |
+| Gemma 2 | 9B, 27B | Google | [Google Team, Google Deepmind](https://storage.googleapis.com/deepmind-media/gemma/gemma-2-report.pdf)                                  |
+| Gemma 3 | 1B, 4B, 12B, 27B | Google | [Google Team, Google Deepmind](https://arxiv.org/pdf/2503.19786)                                  |
+| Llama 2 | 7B, 13B, 70B | Meta AI | [Touvron et al. 2023](https://arxiv.org/abs/2307.09288)                                                                           |
+| Llama 3.1 | 8B, 70B | Meta AI | [Meta AI 2024](https://github.com/meta-llama/llama3)                                                                                 |
+| Llama 3.2 | 1B, 3B | Meta AI | [Meta AI 2024](https://ai.meta.com/blog/llama-3-2-connect-2024-vision-edge-mobile-devices/)                                           |
+| Llama 3.3 | 70B | Meta AI | [Meta AI 2024](https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct)                                                                                 |
+| Mathstral | 7B | Mistral AI | [Mistral AI 2024](https://mistral.ai/news/mathstral/)                                                                                  |
+| MicroLlama | 300M | Ken Wang | [MicroLlama repo](https://github.com/keeeeenw/MicroLlama)                                                                             |
+| Mixtral MoE | 8x7B | Mistral AI | [Mistral AI 2023](https://mistral.ai/news/mixtral-of-experts/)                                                                     |
+| Mistral | 7B, 123B | Mistral AI | [Mistral AI 2023](https://mistral.ai/news/announcing-mistral-7b/)                                                                  |
+| Mixtral MoE | 8x22B | Mistral AI | [Mistral AI 2024](https://mistral.ai/news/mixtral-8x22b/)                                                                         |
+| OLMo | 1B, 7B | Allen Institute for AI (AI2) | [Groeneveld et al. 2024](https://aclanthology.org/2024.acl-long.841/)    |
+| OpenLLaMA | 3B, 7B, 13B | OpenLM Research | [Geng & Liu 2023](https://github.com/openlm-research/open_llama)                                                         |
+| Phi 1.5 & 2 | 1.3B, 2.7B | Microsoft Research  | [Li et al. 2023](https://arxiv.org/abs/2309.05463)                                                                  |
+| Phi 3 | 3.8B | Microsoft Research | [Abdin et al. 2024](https://arxiv.org/abs/2404.14219)                                                                            |
+| Phi 4 | 14B | Microsoft Research | [Abdin et al. 2024](https://arxiv.org/abs/2412.08905)                                                                            |
+| Phi 4 Mini Instruct | 3.8B | Microsoft Research | [Microsoft 2025](https://arxiv.org/abs/2503.01743)                                           |
+| Phi 4 Mini Reasoning | 3.8B | Microsoft Research | [Xu, Peng et al. 2025](https://arxiv.org/abs/2504.21233)                                           |
+| Phi 4 Reasoning | 3.8B | Microsoft Research | [Abdin et al. 2025](https://arxiv.org/abs/2504.21318)                                           |
+| Phi 4 Reasoning Plus | 3.8B | Microsoft Research | [Abdin et al. 2025](https://arxiv.org/abs/2504.21318)                                           |
+| Platypus | 7B, 13B, 70B |  Lee et al. | [Lee, Hunter, and Ruiz 2023](https://arxiv.org/abs/2308.07317)                                                               |
+| Pythia | {14,31,70,160,410}M, {1,1.4,2.8,6.9,12}B | EleutherAI | [Biderman et al. 2023](https://arxiv.org/abs/2304.01373)                                            |
+| Qwen2.5 | 0.5B, 1.5B, 3B, 7B, 14B, 32B, 72B | Alibaba Group | [Qwen Team 2024](https://qwenlm.github.io/blog/qwen2.5/)                                               |
+| Qwen2.5 Coder | 0.5B, 1.5B, 3B, 7B, 14B, 32B | Alibaba Group | [Hui, Binyuan et al. 2024](https://arxiv.org/abs/2409.12186)                                          |
+| Qwen2.5 1M (Long Context) | 7B, 14B | Alibaba Group | [Qwen Team 2025](https://qwenlm.github.io/blog/qwen2.5-1m/)                                          |
+| Qwen2.5 Math | 1.5B, 7B, 72B | Alibaba Group | [An, Yang et al. 2024](https://arxiv.org/abs/2409.12122)                                          |
+| QwQ | 32B | Alibaba Group | [Qwen Team 2025](https://qwenlm.github.io/blog/qwq-32b/)                                                                         |
+| QwQ-Preview | 32B | Alibaba Group | [Qwen Team 2024](https://qwenlm.github.io/blog/qwq-32b-preview/)                                                                         |
+| Qwen3 | 0.6B, 1.7B, 4B, 8B, 14B, 32B | Alibaba Group | [Qwen Team 2025](https://arxiv.org/abs/2505.09388/)                                                                         |
+| Qwen3 MoE | 30B, 235B | Alibaba Group | [Qwen Team 2025](https://arxiv.org/abs/2505.09388/)                                                                         |
+| R1 Distill Llama | 8B, 70B | DeepSeek AI | [DeepSeek AI 2025](https://github.com/deepseek-ai/DeepSeek-R1/blob/main/DeepSeek_R1.pdf)                                                                                 |
+| SmolLM2 | 135M, 360M, 1.7B | Hugging Face | [Hugging Face 2024](https://github.com/huggingface/smollm)                                                               |
+| Salamandra | 2B, 7B | Barcelona Supercomputing Centre | [BSC-LTC 2024](https://github.com/BSC-LTC/salamandra)                                                                         |
+| StableCode | 3B | Stability AI | [Stability AI 2023](https://stability.ai/blog/stablecode-llm-generative-ai-coding)                                                  |
+| StableLM  | 3B, 7B | Stability AI | [Stability AI 2023](https://github.com/Stability-AI/StableLM)                                                                    |
+| StableLM Zephyr | 3B | Stability AI | [Stability AI 2023](https://stability.ai/blog/stablecode-llm-generative-ai-coding)                                             |
+| TinyLlama | 1.1B | Zhang et al. | [Zhang et al. 2023](https://github.com/jzhang38/TinyLlama)                                                                         |
+
+
+**Tip**: You can list all available models by running the `litgpt download list` command.
+
+
+</details>
+
+&nbsp;
+
+---
+
+# Workflows
+
+<p align="center">
+  <a href="#finetune-an-llm">Finetune</a> •
+  <a href="#pretrain-an-llm">Pretrain</a> •
+  <a href="#continue-pretraining-an-llm">Continued pretraining</a> •
+    <a href="#evaluate-an-llm">Evaluate</a> •
+    <a href="#deploy-an-llm">Deploy</a> •
+    <a href="#test-an-llm">Test</a>
+</p>
+
+&nbsp;
+
+Use the command line interface to run advanced workflows such as pretraining or finetuning on your own data.
+
+
+## All workflows
+After installing LitGPT, select the model and workflow to run (finetune, pretrain, evaluate, deploy, etc...):
+
+```bash
+# litgpt [action] [model]
+litgpt  serve     meta-llama/Llama-3.2-3B-Instruct
+litgpt  finetune  meta-llama/Llama-3.2-3B-Instruct
+litgpt  pretrain  meta-llama/Llama-3.2-3B-Instruct
+litgpt  chat      meta-llama/Llama-3.2-3B-Instruct
+litgpt  evaluate  meta-llama/Llama-3.2-3B-Instruct
+```
+
+&nbsp;
+
+----
+
+## Finetune an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-finetune">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/run-on-studio.svg" height="36px" alt="Run on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Finetuning is the process of taking a pretrained AI model and further training it on a smaller, specialized dataset tailored to a specific task or application.
+
+
+&nbsp;
+
+```bash
+# 0) setup your dataset
+curl -L https://huggingface.co/datasets/ksaw008/finance_alpaca/resolve/main/finance_alpaca.json -o my_custom_dataset.json
+
+# 1) Finetune a model (auto downloads weights)
+litgpt finetune microsoft/phi-2 \
+  --data JSON \
+  --data.json_path my_custom_dataset.json \
+  --data.val_split_fraction 0.1 \
+  --out_dir out/custom-model
+
+# 2) Test the model
+litgpt chat out/custom-model/final
+
+# 3) Deploy the model
+litgpt serve out/custom-model/final
+```
+
+[Read the full finetuning docs](tutorials/finetune.md)
+
+&nbsp;
+
+----
+
+## Deploy an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-serve">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/deploy-on-studios.svg" height="36px" alt="Deploy on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Deploy a pretrained or finetune LLM to use it in real-world applications. Deploy, automatically sets up a web server that can be accessed by a website or app.
+
+```bash
+# deploy an out-of-the-box LLM
+litgpt serve microsoft/phi-2
+
+# deploy your own trained model
+litgpt serve path/to/microsoft/phi-2/checkpoint
+```
+
+<details>
+  <summary>Show code to query server:</summary>
+
+&nbsp;
+
+Test the server in a separate terminal and integrate the model API into your AI product:
+```python
+# 3) Use the server (in a separate Python session)
+import requests, json
+response = requests.post(
+    "http://127.0.0.1:8000/predict",
+    json={"prompt": "Fix typos in the following sentence: Example input"}
+)
+print(response.json()["output"])
+```
+</details>
+
+[Read the full deploy docs](tutorials/deploy.md).
+
+&nbsp;
+
+----
+
+## Evaluate an LLM
+Evaluate an LLM to test its performance on various tasks to see how well it understands and generates text. Simply put, we can evaluate things like how well would it do in college-level chemistry, coding, etc... (MMLU, Truthful QA, etc...)
+
+```bash
+litgpt evaluate microsoft/phi-2 --tasks 'truthfulqa_mc2,mmlu'
+```
+
+[Read the full evaluation docs](tutorials/evaluation.md).
+
+&nbsp;
+
+----
+
+##  Test an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-chat">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/run-on-studio.svg" height="36px" alt="Run on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Test how well the model works via an interactive chat. Use the `chat` command to chat, extract embeddings, etc...
+
+Here's an example showing how to use the Phi-2 LLM:
+```bash
+litgpt chat microsoft/phi-2
+
+>> Prompt: What do Llamas eat?
+```
+
+<details>
+  <summary>Full code:</summary>
+
+&nbsp;
+
+```bash
+# 1) List all supported LLMs
+litgpt download list
+
+# 2) Use a model (auto downloads weights)
+litgpt chat microsoft/phi-2
+
+>> Prompt: What do Llamas eat?
+```
+
+The download of certain models requires an additional access token. You can read more about this in the [download](tutorials/download_model_weights.md#specific-models-and-access-tokens) documentation.
+
+</details>
+
+[Read the full chat docs](tutorials/inference.md).
+
+&nbsp;
+
+----
+
+## Pretrain an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-pretrain">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/run-on-studio.svg" height="36px" alt="Run on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Pretraining is the process of teaching an AI model by exposing it to a large amount of data before it is fine-tuned for specific tasks.
+
+<details>
+  <summary>Show code:</summary>
+
+&nbsp;
+
+```bash
+mkdir -p custom_texts
+curl https://www.gutenberg.org/cache/epub/24440/pg24440.txt --output custom_texts/book1.txt
+curl https://www.gutenberg.org/cache/epub/26393/pg26393.txt --output custom_texts/book2.txt
+
+# 1) Download a tokenizer
+litgpt download EleutherAI/pythia-160m \
+  --tokenizer_only True
+
+# 2) Pretrain the model
+litgpt pretrain EleutherAI/pythia-160m \
+  --tokenizer_dir EleutherAI/pythia-160m \
+  --data TextFiles \
+  --data.train_data_path "custom_texts/" \
+  --train.max_tokens 10_000_000 \
+  --out_dir out/custom-model
+
+# 3) Test the model
+litgpt chat out/custom-model/final
+```
+</details>
+
+[Read the full pretraining docs](tutorials/pretrain.md)
+
+&nbsp;
+
+----
+
+## Continue pretraining an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-continue-pretraining">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/run-on-studio.svg" height="36px" alt="Run on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Continued pretraining is another way of finetuning that specializes an already pretrained model by training on custom data:
+
+<details>
+  <summary>Show code:</summary>
+
+&nbsp;
+
+```bash
+mkdir -p custom_texts
+curl https://www.gutenberg.org/cache/epub/24440/pg24440.txt --output custom_texts/book1.txt
+curl https://www.gutenberg.org/cache/epub/26393/pg26393.txt --output custom_texts/book2.txt
+
+# 1) Continue pretraining a model (auto downloads weights)
+litgpt pretrain EleutherAI/pythia-160m \
+  --tokenizer_dir EleutherAI/pythia-160m \
+  --initial_checkpoint_dir EleutherAI/pythia-160m \
+  --data TextFiles \
+  --data.train_data_path "custom_texts/" \
+  --train.max_tokens 10_000_000 \
+  --out_dir out/custom-model
+
+# 2) Test the model
+litgpt chat out/custom-model/final
+```
+
+</details>
+
+[Read the full continued pretraining docs](tutorials/pretrain.md#continued-pretraining-on-custom-data)
+
+&nbsp;
+
+----
+
+# State-of-the-art features
+
+✅ State-of-the-art optimizations: Flash Attention v2, multi-GPU support via fully-sharded data parallelism, [optional CPU offloading](tutorials/oom.md#do-sharding-across-multiple-gpus), and [TPU and XLA support](extensions/xla).</br>
+✅ [Pretrain](tutorials/pretrain.md), [finetune](tutorials/finetune.md), and [deploy](tutorials/inference.md)</br>
+✅ Reduce compute requirements with low-precision settings: FP16, BF16, and FP16/FP32 mixed.</br>
+✅ Lower memory requirements with [quantization](tutorials/quantize.md): 4-bit floats, 8-bit integers, and double quantization.</br>
+✅ [Configuration files](config_hub) for great out-of-the-box performance.</br>
+✅ Parameter-efficient finetuning: [LoRA](tutorials/finetune_lora.md), [QLoRA](tutorials/finetune_lora.md), [Adapter](tutorials/finetune_adapter.md), and [Adapter v2](tutorials/finetune_adapter.md).</br>
+✅ [Exporting](tutorials/convert_lit_models.md) to other popular model weight formats.</br>
+✅ Many popular datasets for [pretraining](tutorials/pretrain.md) and [finetuning](tutorials/prepare_dataset.md), and [support for custom datasets](tutorials/prepare_dataset.md#preparing-custom-datasets-for-instruction-finetuning).</br>
+✅ Readable and easy-to-modify code to experiment with the latest research ideas.</br>
+
+&nbsp;
+
+---
+
+# Training recipes
+
+LitGPT comes with validated recipes (YAML configs) to train models under different conditions.  We've generated these recipes based on the parameters we found to perform the best for different training conditions.
+
+Browse all training recipes [here](config_hub).
+
+### Example
+
+```bash
+litgpt finetune \
+  --config https://raw.githubusercontent.com/Lightning-AI/litgpt/main/config_hub/finetune/llama-2-7b/lora.yaml
+```
+<details>
+  <summary>✅ Use configs to customize training</summary>
+
+Configs let you customize training for all granular parameters like:
+
+```yaml
+# The path to the base model's checkpoint directory to load for finetuning. (type: <class 'Path'>, default: checkpoints/stabilityai/stablelm-base-alpha-3b)
+checkpoint_dir: checkpoints/meta-llama/Llama-2-7b-hf
+
+# Directory in which to save checkpoints and logs. (type: <class 'Path'>, default: out/lora)
+out_dir: out/finetune/qlora-llama2-7b
+
+# The precision to use for finetuning. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-true
+
+...
+```
+</details>
+
+<details>
+  <summary>✅ Example: LoRA finetuning config</summary>
+
+&nbsp;
+
+```yaml
+# The path to the base model's checkpoint directory to load for finetuning. (type: <class 'Path'>, default: checkpoints/stabilityai/stablelm-base-alpha-3b)
+checkpoint_dir: checkpoints/meta-llama/Llama-2-7b-hf
+
+# Directory in which to save checkpoints and logs. (type: <class 'Path'>, default: out/lora)
+out_dir: out/finetune/qlora-llama2-7b
+
+# The precision to use for finetuning. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-true
+
+# If set, quantize the model with this algorithm. See ``tutorials/quantize.md`` for more information. (type: Optional[Literal['nf4', 'nf4-dq', 'fp4', 'fp4-dq', 'int8-training']], default: null)
+quantize: bnb.nf4
+
+# How many devices/GPUs to use. (type: Union[int, str], default: 1)
+devices: 1
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# The LoRA rank. (type: int, default: 8)
+lora_r: 32
+
+# The LoRA alpha. (type: int, default: 16)
+lora_alpha: 16
+
+# The LoRA dropout value. (type: float, default: 0.05)
+lora_dropout: 0.05
+
+# Whether to apply LoRA to the query weights in attention. (type: bool, default: True)
+lora_query: true
+
+# Whether to apply LoRA to the key weights in attention. (type: bool, default: False)
+lora_key: false
+
+# Whether to apply LoRA to the value weights in attention. (type: bool, default: True)
+lora_value: true
+
+# Whether to apply LoRA to the output projection in the attention block. (type: bool, default: False)
+lora_projection: false
+
+# Whether to apply LoRA to the weights of the MLP in the attention block. (type: bool, default: False)
+lora_mlp: false
+
+# Whether to apply LoRA to output head in GPT. (type: bool, default: False)
+lora_head: false
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.Alpaca``.
+data:
+  class_path: litgpt.data.Alpaca2k
+  init_args:
+    mask_prompt: false
+    val_split_fraction: 0.05
+    prompt_style: alpaca
+    ignore_index: -100
+    seed: 42
+    num_workers: 4
+    download_dir: data/alpaca2k
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 200
+
+  # 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: 128)
+  global_batch_size: 8
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 2
+
+  # Number of iterations with learning rate warmup active (type: int, default: 100)
+  lr_warmup_steps: 10
+
+  # Number of epochs to train on (type: Optional[int], default: 5)
+  epochs: 4
+
+  # Total number of tokens to train on (type: Optional[int], default: null)
+  max_tokens:
+
+  # Limits the number of optimizer steps to run (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples (type: Optional[int], default: null)
+  max_seq_length: 512
+
+  # Whether to tie the embedding weights with the language modeling head weights (type: Optional[bool], default: null)
+  tie_embeddings:
+
+  #   (type: float, default: 0.0003)
+  learning_rate: 0.0002
+
+  #   (type: float, default: 0.02)
+  weight_decay: 0.0
+
+  #   (type: float, default: 0.9)
+  beta1: 0.9
+
+  #   (type: float, default: 0.95)
+  beta2: 0.95
+
+  #   (type: Optional[float], default: null)
+  max_norm:
+
+  #   (type: float, default: 6e-05)
+  min_lr: 6.0e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+
+  # Number of optimizer steps between evaluation calls (type: int, default: 100)
+  interval: 100
+
+  # Number of tokens to generate (type: Optional[int], default: 100)
+  max_new_tokens: 100
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 100
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: csv)
+logger_name: csv
+
+# The random seed to use for reproducibility. (type: int, default: 1337)
+seed: 1337
+```
+</details>
+
+<details>
+  <summary>✅ Override any parameter in the CLI:</summary>
+
+```bash
+litgpt finetune \
+  --config https://raw.githubusercontent.com/Lightning-AI/litgpt/main/config_hub/finetune/llama-2-7b/lora.yaml \
+  --lora_r 4
+```
+</details>
+
+&nbsp;
+
+----
+
+# Project highlights
+
+LitGPT powers many great AI projects, initiatives, challenges and of course enterprises. Please submit a pull request to be considered for a feature.
+
+<details>
+  <summary>📊 SAMBA: Simple Hybrid State Space Models for Efficient Unlimited Context Language Modeling</summary>
+
+The [Samba](https://github.com/microsoft/Samba) project by researchers at Microsoft is built on top of the LitGPT code base and combines state space models with sliding window attention, which outperforms pure state space models.
+
+</details>
+
+<details>
+  <summary>🏆 NeurIPS 2023 Large Language Model Efficiency Challenge: 1 LLM + 1 GPU + 1 Day</summary>
+
+The LitGPT repository was the official starter kit for the [NeurIPS 2023 LLM Efficiency Challenge](https://llm-efficiency-challenge.github.io), which is a competition focused on finetuning an existing non-instruction tuned LLM for 24 hours on a single GPU.
+
+</details>
+
+<details>
+  <summary>🦙 TinyLlama: An Open-Source Small Language Model</summary>
+
+
+LitGPT powered the [TinyLlama project](https://github.com/jzhang38/TinyLlama) and [TinyLlama: An Open-Source Small Language Model](https://arxiv.org/abs/2401.02385) research paper.
+
+</details>
+
+<details>
+  <summary>🍪 MicroLlama: MicroLlama-300M</summary>
+
+[MicroLlama](https://github.com/keeeeenw/MicroLlama) is a 300M Llama model pretrained on 50B tokens powered by TinyLlama and LitGPT.
+</details>
+
+<details>
+  <summary>🔬 Pre-training Small Base LMs with Fewer Tokens</summary>
+
+The research paper ["Pre-training Small Base LMs with Fewer Tokens"](https://arxiv.org/abs/2404.08634), which utilizes LitGPT, develops smaller base language models by inheriting a few transformer blocks from larger models and training on a tiny fraction of the data used by the larger models. It demonstrates that these smaller models can perform comparably to larger models despite using significantly less training data and resources.
+
+</details>
+
+&nbsp;
+
+----
+
+# Community
+
+We welcome all individual contributors, regardless of their level of experience or hardware. Your contributions are valuable, and we are excited to see what you can accomplish in this collaborative and supportive environment.
+
+- [Request a feature](https://github.com/Lightning-AI/litgpt/issues)
+- [Submit your first contribution](https://lightning.ai/pages/community/tutorial/how-to-contribute-to-litgpt/)
+- [Join our Discord](https://discord.gg/VptPCZkGNa)
+
+&nbsp;
+
+# Tutorials
+
+🚀 [Get started](tutorials/0_to_litgpt.md)</br>
+⚡️ [Finetuning, incl. LoRA, QLoRA, and Adapters](tutorials/finetune.md)</br>
+🤖 [Pretraining](tutorials/pretrain.md)</br>
+💬 [Model evaluation](tutorials/evaluation.md)</br>
+📘 [Supported and custom datasets](tutorials/prepare_dataset.md)</br>
+🧹 [Quantization](tutorials/quantize.md)</br>
+🤯 [Tips for dealing with out-of-memory (OOM) errors](tutorials/oom.md)</br>
+🧑🏽‍💻 [Using cloud TPUs](extensions/xla)</br>
+
+&nbsp;
+
+----
+
+### Acknowledgments
+
+This implementation extends on [Lit-LLaMA](https://github.com/lightning-AI/lit-llama) and [nanoGPT](https://github.com/karpathy/nanoGPT), and it's **powered by [Lightning Fabric](https://lightning.ai/docs/fabric/stable/) ⚡**.
+
+- [@karpathy](https://github.com/karpathy) for [nanoGPT](https://github.com/karpathy/nanoGPT)
+- [@EleutherAI](https://github.com/EleutherAI) for [GPT-NeoX](https://github.com/EleutherAI/gpt-neox) and the [Evaluation Harness](https://github.com/EleutherAI/lm-evaluation-harness)
+- [@TimDettmers](https://github.com/TimDettmers) for [bitsandbytes](https://github.com/TimDettmers/bitsandbytes)
+- [@Microsoft](https://github.com/microsoft) for [LoRA](https://github.com/microsoft/LoRA)
+- [@tridao](https://github.com/tridao) for [Flash Attention 2](https://github.com/Dao-AILab/flash-attention)
+
+### License
+
+LitGPT is released under the [Apache 2.0](https://github.com/Lightning-AI/litgpt/blob/main/LICENSE) license.
+
+### Citation
+
+If you use LitGPT in your research, please cite the following work:
+
+```bibtex
+@misc{litgpt-2023,
+  author       = {Lightning AI},
+  title        = {LitGPT},
+  howpublished = {\url{https://github.com/Lightning-AI/litgpt}},
+  year         = {2023},
+}
+```
+
+&nbsp;

check.py

@@ -0,0 +1,34 @@
+import os
+import json
+import argparse
+
+def check_file(path):
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)  # 这里假设每个文件是一个 JSON 数组
+    total = len(data)
+    # 转换成字符串来判断重复（保证字典可哈希）
+    unique = len({json.dumps(item, sort_keys=True) for item in data})
+    duplicates = total - unique
+    return total, duplicates
+
+def main():
+    parser = argparse.ArgumentParser(description="Check JSON array dataset files for row count and duplicates.")
+    parser.add_argument("folder", help="Folder containing the JSON files")
+    args = parser.parse_args()
+
+    folder = args.folder
+    for fname in sorted(os.listdir(folder)):
+        fpath = os.path.join(folder, fname)
+        if not os.path.isfile(fpath):
+            continue
+        if not fname.endswith(".json"):
+            continue
+        try:
+            total, duplicates = check_file(fpath)
+            print(f"{fname:25} rows={total:6}  duplicates={duplicates:4}")
+        except Exception as e:
+            print(f"{fname:25} [ERROR: {e}]")
+
+if __name__ == "__main__":
+    main()
+

cmd_start_for.ini

@@ -0,0 +1,2 @@
+[cmd_start_info]
+game_id=26

delete.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import argparse
+import pathlib
+import re
+import shutil
+
+def remove_explanation_fields(text: str) -> str:
+    """
+    删除 JSON 文本中键为 "explanation" 的键值对（值为字符串），
+    不使用 json 解析，使用正则在词法层面安全处理转义字符。
+    同时正确处理前后逗号，保持 JSON 仍然有效。
+    """
+
+    # JSON 字符串匹配：支持任意数量的转义字符（如 \" \\ \n ...）
+    # 说明：JSON 字符串不允许出现未转义的换行，因此不需 DOTALL。
+    json_string = r'"(?:\\.|[^"\\])*"'
+
+    # 情况 A：explanation 在中间/开头，后面跟逗号
+    #   ... "explanation": "......", ...
+    pattern_after = re.compile(
+        rf'\s*"explanation"\s*:\s*{json_string}\s*,'
+    )
+
+    # 情况 B：explanation 在中间/末尾，前面有逗号
+    #   ..., "explanation": "......"
+    pattern_before = re.compile(
+        rf',\s*"explanation"\s*:\s*{json_string}'
+    )
+
+    # 先删“后跟逗号”的情况，再删“前有逗号”的情况
+    new_text = pattern_after.sub('', text)
+    new_text = pattern_before.sub('', new_text)
+
+    # 情况 C：对象里只有一个键值对（既没有前逗号也没有后逗号）
+    # 比如：{ "explanation": "..." }
+    # 这会在 A/B 后仍残留：{  }（已是合法 JSON），无需额外处理。
+    # 若出现花括号内部多余空白也不影响合法性。
+
+    return new_text
+
+def process_file(p: pathlib.Path, dry_run: bool = False) -> bool:
+    original = p.read_text(encoding='utf-8')
+    repaired = remove_explanation_fields(original)
+    if repaired != original:
+        if not dry_run:
+            # 备份
+            backup = p.with_suffix(p.suffix + '.bak')
+            shutil.copyfile(p, backup)
+            # 覆盖
+            p.write_text(repaired, encoding='utf-8')
+        return True
+    return False
+
+def main():
+    ap = argparse.ArgumentParser(
+        description="在不使用 json 解析的前提下，删除所有 JSON 文件中的 \"explanation\": \"...\" 字段（安全处理转义字符与逗号）。"
+    )
+    ap.add_argument("folder", type=str, help="包含 .json 文件的文件夹路径")
+    ap.add_argument("--dry-run", action="store_true", help="仅显示将要修改的文件，不写回")
+    args = ap.parse_args()
+
+    root = pathlib.Path(args.folder)
+    if not root.is_dir():
+        raise SystemExit(f"路径不存在或不是文件夹：{root}")
+
+    changed = 0
+    total = 0
+    for p in sorted(root.glob("*.json")):
+        total += 1
+        if process_file(p, dry_run=args.dry_run):
+            changed += 1
+            print(f"[UPDATED] {p}")
+        else:
+            print(f"[SKIP   ] {p}（无 explanation 字段或无需修改）")
+
+    print(f"\n完成：扫描 {total} 个 .json 文件，修改 {changed} 个。")
+    if not args.dry_run:
+        print("已为修改过的文件生成 .bak 备份。")
+
+if __name__ == "__main__":
+    main()

environment.yml

@@ -0,0 +1,261 @@
+name: /mnt/data/llmtcl
+channels:
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - bzip2=1.0.8=h5eee18b_6
+  - ca-certificates=2025.2.25=h06a4308_0
+  - expat=2.7.1=h6a678d5_0
+  - ld_impl_linux-64=2.40=h12ee557_0
+  - libffi=3.4.4=h6a678d5_1
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libuuid=1.41.5=h5eee18b_0
+  - libxcb=1.17.0=h9b100fa_0
+  - ncurses=6.5=h7934f7d_0
+  - openssl=3.0.17=h5eee18b_0
+  - pip=25.1=pyhc872135_2
+  - pthread-stubs=0.3=h0ce48e5_1
+  - python=3.10.18=h1a3bd86_0
+  - readline=8.2=h5eee18b_0
+  - setuptools=78.1.1=py310h06a4308_0
+  - sqlite=3.50.2=hb25bd0a_1
+  - tk=8.6.14=h993c535_1
+  - wheel=0.45.1=py310h06a4308_0
+  - xorg-libx11=1.8.12=h9b100fa_1
+  - xorg-libxau=1.0.12=h9b100fa_0
+  - xorg-libxdmcp=1.1.5=h9b100fa_0
+  - xorg-xorgproto=2024.1=h5eee18b_1
+  - xz=5.6.4=h5eee18b_1
+  - zlib=1.2.13=h5eee18b_1
+  - pip:
+      - absl-py==2.3.1
+      - accelerate==1.10.0
+      - aiohappyeyeballs==2.6.1
+      - aiohttp==3.12.15
+      - aiosignal==1.4.0
+      - annotated-types==0.7.0
+      - anyio==4.10.0
+      - astor==0.8.1
+      - async-timeout==5.0.1
+      - attrs==25.3.0
+      - blake3==1.0.5
+      - boto3==1.40.1
+      - botocore==1.40.1
+      - cachetools==6.2.0
+      - cbor2==5.7.0
+      - certifi==2025.8.3
+      - cffi==2.0.0
+      - cfgv==3.4.0
+      - chardet==5.2.0
+      - charset-normalizer==3.4.2
+      - click==8.2.1
+      - cloudpickle==3.1.1
+      - colorama==0.4.6
+      - compressed-tensors==0.10.2
+      - contourpy==1.3.2
+      - coverage==7.10.6
+      - cupy-cuda12x==13.6.0
+      - cycler==0.12.1
+      - dataproperty==1.1.0
+      - datasets==3.6.0
+      - depyf==0.19.0
+      - dill==0.3.8
+      - diskcache==5.6.3
+      - distlib==0.4.0
+      - distro==1.9.0
+      - dnspython==2.8.0
+      - docstring-parser==0.17.0
+      - einops==0.8.1
+      - email-validator==2.3.0
+      - et-xmlfile==2.0.0
+      - evaluate==0.4.5
+      - exceptiongroup==1.3.0
+      - execnet==2.1.1
+      - fastapi==0.116.1
+      - fastapi-cli==0.0.11
+      - fastapi-cloud-cli==0.1.5
+      - fastrlock==0.8.3
+      - filelock==3.18.0
+      - fonttools==4.59.0
+      - frozenlist==1.7.0
+      - fsspec==2025.3.0
+      - gguf==0.17.1
+      - grpcio==1.74.0
+      - h11==0.16.0
+      - hf-transfer==0.1.9
+      - hf-xet==1.1.5
+      - httpcore==1.0.9
+      - httptools==0.6.4
+      - httpx==0.28.1
+      - huggingface-hub==0.34.4
+      - identify==2.6.14
+      - idna==3.10
+      - importlib-resources==6.5.2
+      - iniconfig==2.1.0
+      - interegular==0.3.3
+      - jinja2==3.1.6
+      - jiter==0.10.0
+      - jmespath==1.0.1
+      - joblib==1.5.1
+      - jsonargparse==4.40.1
+      - jsonlines==4.0.0
+      - jsonschema==4.25.1
+      - jsonschema-specifications==2025.9.1
+      - kiwisolver==1.4.9
+      - lark==1.2.2
+      - lightning==2.5.2
+      - lightning-utilities==0.15.0
+      - litdata==0.2.51
+      - litgpt==0.5.9
+      - llguidance==0.7.30
+      - llvmlite==0.44.0
+      - lm-eval==0.4.9.1
+      - lm-format-enforcer==0.10.12
+      - lxml==6.0.0
+      - markdown==3.8.2
+      - markdown-it-py==4.0.0
+      - markupsafe==3.0.2
+      - matplotlib==3.10.5
+      - mbstrdecoder==1.1.4
+      - mdurl==0.1.2
+      - mistral-common==1.8.4
+      - more-itertools==10.7.0
+      - mpmath==1.3.0
+      - msgpack==1.1.1
+      - msgspec==0.19.0
+      - multidict==6.6.3
+      - multiprocess==0.70.16
+      - networkx==3.4.2
+      - ninja==1.13.0
+      - nltk==3.9.1
+      - nodeenv==1.9.1
+      - numba==0.61.2
+      - numexpr==2.11.0
+      - numpy==2.2.6
+      - nvidia-cublas-cu12==12.6.4.1
+      - nvidia-cuda-cupti-cu12==12.6.80
+      - nvidia-cuda-nvrtc-cu12==12.6.77
+      - nvidia-cuda-runtime-cu12==12.6.77
+      - nvidia-cudnn-cu12==9.5.1.17
+      - nvidia-cufft-cu12==11.3.0.4
+      - nvidia-cufile-cu12==1.11.1.6
+      - nvidia-curand-cu12==10.3.7.77
+      - nvidia-cusolver-cu12==11.7.1.2
+      - nvidia-cusparse-cu12==12.5.4.2
+      - nvidia-cusparselt-cu12==0.6.3
+      - nvidia-nccl-cu12==2.26.2
+      - nvidia-nvjitlink-cu12==12.6.85
+      - nvidia-nvtx-cu12==12.6.77
+      - obstore==0.7.3
+      - openai==1.107.0
+      - openai-harmony==0.0.4
+      - opencv-python-headless==4.12.0.88
+      - openpyxl==3.1.5
+      - outlines-core==0.2.10
+      - packaging==25.0
+      - pandas==2.3.1
+      - partial-json-parser==0.2.1.1.post6
+      - pathvalidate==3.3.1
+      - peft==0.17.0
+      - pillow==11.3.0
+      - platformdirs==4.4.0
+      - pluggy==1.6.0
+      - portalocker==3.2.0
+      - pre-commit==4.3.0
+      - prometheus-client==0.22.1
+      - prometheus-fastapi-instrumentator==7.1.0
+      - propcache==0.3.2
+      - protobuf==6.31.1
+      - psutil==7.0.0
+      - py-cpuinfo==9.0.0
+      - pyarrow==21.0.0
+      - pybase64==1.4.2
+      - pybind11==3.0.0
+      - pycountry==24.6.1
+      - pycparser==2.23
+      - pydantic==2.11.7
+      - pydantic-core==2.33.2
+      - pydantic-extra-types==2.10.5
+      - pygments==2.19.2
+      - pyparsing==3.2.3
+      - pytablewriter==1.2.1
+      - pytest==8.4.2
+      - pytest-cov==6.3.0
+      - pytest-xdist==3.8.0
+      - python-dateutil==2.9.0.post0
+      - python-dotenv==1.1.1
+      - python-json-logger==3.3.0
+      - python-multipart==0.0.20
+      - pytorch-lightning==2.5.2
+      - pytz==2025.2
+      - pyyaml==6.0.2
+      - pyzmq==27.1.0
+      - ray==2.49.1
+      - referencing==0.36.2
+      - regex==2025.7.34
+      - requests==2.32.4
+      - rich==14.1.0
+      - rich-toolkit==0.15.1
+      - rignore==0.6.4
+      - rouge-score==0.1.2
+      - rpds-py==0.27.1
+      - s3transfer==0.13.1
+      - sacrebleu==2.5.1
+      - safetensors==0.5.3
+      - scikit-learn==1.7.1
+      - scipy==1.15.3
+      - seaborn==0.13.2
+      - sentencepiece==0.2.0
+      - sentry-sdk==2.37.1
+      - setproctitle==1.3.7
+      - shellingham==1.5.4
+      - six==1.17.0
+      - sniffio==1.3.1
+      - soundfile==0.13.1
+      - soxr==1.0.0
+      - sqlitedict==2.1.0
+      - starlette==0.47.3
+      - sympy==1.14.0
+      - tabledata==1.3.4
+      - tabulate==0.9.0
+      - tcolorpy==0.1.7
+      - tenacity==9.1.2
+      - tensorboard==2.20.0
+      - tensorboard-data-server==0.7.2
+      - threadpoolctl==3.6.0
+      - tifffile==2025.5.10
+      - tiktoken==0.11.0
+      - tokenizers==0.21.4
+      - tomli==2.2.1
+      - torch==2.7.1
+      - torchaudio==2.7.1
+      - torchmetrics==1.8.0
+      - torchvision==0.22.1
+      - tqdm==4.67.1
+      - tqdm-multiprocess==0.0.11
+      - transformers==4.55.0
+      - triton==3.3.1
+      - typepy==1.3.4
+      - typer==0.17.4
+      - typeshed-client==2.8.2
+      - typing-extensions==4.14.1
+      - typing-inspection==0.4.1
+      - tzdata==2025.2
+      - urllib3==2.5.0
+      - uvicorn==0.35.0
+      - uvloop==0.21.0
+      - virtualenv==20.34.0
+      - vllm==0.10.1.1
+      - watchfiles==1.1.0
+      - websockets==15.0.1
+      - werkzeug==3.1.3
+      - word2number==1.1
+      - xformers==0.0.31
+      - xgrammar==0.1.21
+      - xxhash==3.5.0
+      - yarl==1.20.1
+      - zstandard==0.23.0
+prefix: /mnt/data/llmtcl

fix.py

@@ -0,0 +1,45 @@
+import re
+import pathlib
+import shutil
+import argparse
+
+def escape_backslashes_in_questions(text: str) -> str:
+    # 匹配 "question": "..."
+    json_string = r'"(?:\\.|[^"\\])*"'
+    pattern = re.compile(rf'("question"\s*:\s*)({json_string})')
+
+    def replacer(m):
+        prefix, raw = m.groups()
+        # 去掉外层引号
+        inner = raw[1:-1]
+        # 把单反斜杠替换成双反斜杠
+        inner_fixed = inner.replace("\\", "\\\\")
+        return f'{prefix}"{inner_fixed}"'
+
+    return pattern.sub(replacer, text)
+
+def process_file(p: pathlib.Path):
+    original = p.read_text(encoding="utf-8")
+    fixed = escape_backslashes_in_questions(original)
+    if fixed != original:
+        shutil.copyfile(p, p.with_suffix(p.suffix + ".bak"))
+        p.write_text(fixed, encoding="utf-8")
+        print(f"[UPDATED] {p}")
+    else:
+        print(f"[SKIP   ] {p}")
+
+def main():
+    ap = argparse.ArgumentParser(description="Fix backslashes in 'question' fields of JSON files")
+    ap.add_argument("folder", type=str, help="Directory containing .json files")
+    args = ap.parse_args()
+
+    root = pathlib.Path(args.folder)
+    if not root.is_dir():
+        print(f"[ERROR] {args.folder} is not a valid directory")
+        return
+
+    for p in root.glob("*.json"):
+        process_file(p)
+
+if __name__ == "__main__":
+    main()

litgpt.egg-info/PKG-INFO

@@ -0,0 +1,977 @@
+Metadata-Version: 2.4
+Name: litgpt
+Version: 0.5.9
+Summary: Hackable implementation of state-of-the-art open-source LLMs
+Author-email: Lightning AI <contact@lightning.ai>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [2023] Lightning AI
+        
+           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.
+        
+Project-URL: documentation, https://github.com/lightning-AI/litgpt/tutorials
+Project-URL: homepage, https://github.com/lightning-AI/litgpt
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: huggingface-hub<0.33,>=0.23.5
+Requires-Dist: jsonargparse[signatures]<=4.32.1,>=4.30.1; python_version <= "3.9"
+Requires-Dist: jsonargparse[signatures]>=4.37; python_version > "3.9"
+Requires-Dist: lightning>=2.5
+Requires-Dist: psutil==7
+Requires-Dist: safetensors>=0.4.3
+Requires-Dist: tokenizers>=0.15.2
+Requires-Dist: torch>=2.5
+Requires-Dist: tqdm>=4.66
+Provides-Extra: compiler
+Requires-Dist: lightning-thunder>=0.2.0.dev20250119; (python_version >= "3.10" and sys_platform == "linux") and extra == "compiler"
+Provides-Extra: extra
+Requires-Dist: bitsandbytes<0.43,>=0.42; sys_platform == "darwin" and extra == "extra"
+Requires-Dist: bitsandbytes<0.45.5,>=0.45.2; (sys_platform == "linux" or sys_platform == "win32") and extra == "extra"
+Requires-Dist: datasets<4,>=2.18; extra == "extra"
+Requires-Dist: huggingface-hub[hf-transfer]>=0.21; extra == "extra"
+Requires-Dist: litdata==0.2.51; extra == "extra"
+Requires-Dist: litserve>0.2; extra == "extra"
+Requires-Dist: lm-eval>=0.4.2; extra == "extra"
+Requires-Dist: pandas>=1.9; extra == "extra"
+Requires-Dist: pyarrow>=15.0.2; extra == "extra"
+Requires-Dist: requests>=2.31; extra == "extra"
+Requires-Dist: sentencepiece>=0.2; extra == "extra"
+Requires-Dist: tensorboard>=2.14; extra == "extra"
+Requires-Dist: torchmetrics>=1.3.1; extra == "extra"
+Requires-Dist: transformers<4.52,>=4.51.3; extra == "extra"
+Requires-Dist: uvloop>=0.2; sys_platform != "win32" and extra == "extra"
+Requires-Dist: zstandard>=0.22; extra == "extra"
+Provides-Extra: test
+Requires-Dist: einops>=0.7; extra == "test"
+Requires-Dist: protobuf>=4.23.4; extra == "test"
+Requires-Dist: pytest>=8.1.1; extra == "test"
+Requires-Dist: pytest-benchmark>=5.1; extra == "test"
+Requires-Dist: pytest-dependency>=0.6; extra == "test"
+Requires-Dist: pytest-rerunfailures>=14; extra == "test"
+Requires-Dist: pytest-timeout>=2.3.1; extra == "test"
+Dynamic: license-file
+
+<div align="center">
+
+
+# ⚡ LitGPT
+
+**20+ high-performance LLMs with recipes to pretrain, finetune, and deploy at scale.**
+
+<pre>
+✅ From scratch implementations      ✅ No abstractions         ✅ Beginner friendly
+   ✅ Flash attention                   ✅ FSDP                    ✅ LoRA, QLoRA, Adapter
+✅ Reduce GPU memory (fp4/8/16/32)   ✅ 1-1000+ GPUs/TPUs       ✅ 20+ LLMs         
+</pre>
+
+
+---
+
+
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytorch-lightning)
+![cpu-tests](https://github.com/lightning-AI/lit-stablelm/actions/workflows/cpu-tests.yml/badge.svg) [![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/Lightning-AI/lit-stablelm/blob/master/LICENSE) [![Discord](https://img.shields.io/discord/1077906959069626439)](https://discord.gg/VptPCZkGNa)
+
+<p align="center">
+  <a href="#quick-start">Quick start</a> •
+  <a href="#choose-from-20-llms">Models</a> •
+  <a href="#finetune-an-llm">Finetune</a> •
+  <a href="#deploy-an-llm">Deploy</a> •
+  <a href="#all-workflows">All workflows</a> •
+  <a href="#state-of-the-art-features">Features</a> •
+  <a href="#training-recipes">Recipes (YAML)</a> •
+  <a href="https://lightning.ai/">Lightning AI</a> •
+    <a href="#tutorials">Tutorials</a>
+</p>
+
+&nbsp;
+
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-quick-start">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/get-started-badge.svg" height="36px" alt="Get started"/>
+</a>
+
+&nbsp;
+
+</div>
+
+# Use, finetune, pretrain, and deploy LLMs Lightning fast ⚡⚡
+Every LLM is implemented from scratch with **no abstractions** and **full control**, making them blazing fast, minimal, and performant at enterprise scale.
+
+✅ **Enterprise ready -** Apache 2.0 for unlimited enterprise use.</br>
+✅ **Developer friendly -** Easy debugging with no abstraction layers and single file implementations.</br>
+✅ **Optimized performance -** Models designed to maximize performance, reduce costs, and speed up training.</br>
+✅ **Proven recipes -** Highly-optimized training/finetuning recipes tested at enterprise scale.</br>
+
+&nbsp;
+
+# Quick start
+Install LitGPT
+```
+pip install 'litgpt[extra]'
+```
+
+Load and use any of the [20+ LLMs](#choose-from-20-llms):
+```python
+from litgpt import LLM
+
+llm = LLM.load("microsoft/phi-2")
+text = llm.generate("Fix the spelling: Every fall, the family goes to the mountains.")
+print(text)
+# Corrected Sentence: Every fall, the family goes to the mountains.
+```
+
+&nbsp;
+
+✅ Optimized for fast inference</br>
+✅ Quantization</br>
+✅ Runs on low-memory GPUs</br>
+✅ No layers of internal abstractions</br>
+✅ Optimized for production scale</br>
+
+<details>
+  <summary>Advanced install options</summary>
+
+Install from source:
+
+```bash
+git clone https://github.com/Lightning-AI/litgpt
+cd litgpt
+pip install -e '.[all]'
+```
+</details>
+
+[Explore the full Python API docs](tutorials/python-api.md).
+
+&nbsp;
+
+---
+# Choose from 20+ LLMs
+Every model is written from scratch to maximize performance and remove layers of abstraction:
+
+| Model | Model size | Author | Reference |
+|----|----|----|----|
+| Llama 3, 3.1, 3.2, 3.3 | 1B, 3B, 8B, 70B, 405B | Meta AI | [Meta AI 2024](https://github.com/meta-llama/llama3)                                           |
+| Code Llama | 7B, 13B, 34B, 70B | Meta AI | [Rozière et al. 2023](https://arxiv.org/abs/2308.12950)                                       |
+| CodeGemma | 7B | Google | [Google Team, Google Deepmind](https://ai.google.dev/gemma/docs/codegemma)                                     |
+| Gemma 2 | 2B, 9B, 27B | Google | [Google Team, Google Deepmind](https://storage.googleapis.com/deepmind-media/gemma/gemma-2-report.pdf)  |
+| Phi 4 | 14B | Microsoft Research | [Abdin et al. 2024](https://arxiv.org/abs/2412.08905)                                                                            |
+| Qwen2.5 | 0.5B, 1.5B, 3B, 7B, 14B, 32B, 72B | Alibaba Group | [Qwen Team 2024](https://qwenlm.github.io/blog/qwen2.5/)                                               |
+| Qwen2.5 Coder | 0.5B, 1.5B, 3B, 7B, 14B, 32B | Alibaba Group | [Hui, Binyuan et al. 2024](https://arxiv.org/abs/2409.12186)                                          |
+| R1 Distill Llama | 8B, 70B | DeepSeek AI | [DeepSeek AI 2025](https://github.com/deepseek-ai/DeepSeek-R1/blob/main/DeepSeek_R1.pdf)                                                                                 |
+| ... | ... | ... | ...   |
+
+<details>
+  <summary>See full list of 20+ LLMs</summary>
+
+&nbsp;
+
+#### All models
+
+| Model | Model size | Author | Reference |
+|----|----|----|----|
+| CodeGemma | 7B | Google | [Google Team, Google Deepmind](https://ai.google.dev/gemma/docs/codegemma)                                                                 |
+| Code Llama | 7B, 13B, 34B, 70B | Meta AI | [Rozière et al. 2023](https://arxiv.org/abs/2308.12950)                                                                   |
+| Falcon | 7B, 40B, 180B | TII UAE | [TII 2023](https://falconllm.tii.ae)                                                                                              |
+| Falcon 3 | 1B, 3B, 7B, 10B | TII UAE | [TII 2024](https://huggingface.co/blog/falcon3)                                                                                              |
+| FreeWilly2 (Stable Beluga 2) | 70B | Stability AI | [Stability AI 2023](https://stability.ai/blog/stable-beluga-large-instruction-fine-tuned-models)                 |
+| Function Calling Llama 2 | 7B | Trelis | [Trelis et al. 2023](https://huggingface.co/Trelis/Llama-2-7b-chat-hf-function-calling-v2)                                  |
+| Gemma | 2B, 7B | Google | [Google Team, Google Deepmind](https://storage.googleapis.com/deepmind-media/gemma/gemma-report.pdf)                                       |
+| Gemma 2 | 9B, 27B | Google | [Google Team, Google Deepmind](https://storage.googleapis.com/deepmind-media/gemma/gemma-2-report.pdf)                                  |
+| Gemma 3 | 1B, 4B, 12B, 27B | Google | [Google Team, Google Deepmind](https://arxiv.org/pdf/2503.19786)                                  |
+| Llama 2 | 7B, 13B, 70B | Meta AI | [Touvron et al. 2023](https://arxiv.org/abs/2307.09288)                                                                           |
+| Llama 3.1 | 8B, 70B | Meta AI | [Meta AI 2024](https://github.com/meta-llama/llama3)                                                                                 |
+| Llama 3.2 | 1B, 3B | Meta AI | [Meta AI 2024](https://ai.meta.com/blog/llama-3-2-connect-2024-vision-edge-mobile-devices/)                                           |
+| Llama 3.3 | 70B | Meta AI | [Meta AI 2024](https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct)                                                                                 |
+| Mathstral | 7B | Mistral AI | [Mistral AI 2024](https://mistral.ai/news/mathstral/)                                                                                  |
+| MicroLlama | 300M | Ken Wang | [MicroLlama repo](https://github.com/keeeeenw/MicroLlama)                                                                             |
+| Mixtral MoE | 8x7B | Mistral AI | [Mistral AI 2023](https://mistral.ai/news/mixtral-of-experts/)                                                                     |
+| Mistral | 7B, 123B | Mistral AI | [Mistral AI 2023](https://mistral.ai/news/announcing-mistral-7b/)                                                                  |
+| Mixtral MoE | 8x22B | Mistral AI | [Mistral AI 2024](https://mistral.ai/news/mixtral-8x22b/)                                                                         |
+| OLMo | 1B, 7B | Allen Institute for AI (AI2) | [Groeneveld et al. 2024](https://aclanthology.org/2024.acl-long.841/)    |
+| OpenLLaMA | 3B, 7B, 13B | OpenLM Research | [Geng & Liu 2023](https://github.com/openlm-research/open_llama)                                                         |
+| Phi 1.5 & 2 | 1.3B, 2.7B | Microsoft Research  | [Li et al. 2023](https://arxiv.org/abs/2309.05463)                                                                  |
+| Phi 3 | 3.8B | Microsoft Research | [Abdin et al. 2024](https://arxiv.org/abs/2404.14219)                                                                            |
+| Phi 4 | 14B | Microsoft Research | [Abdin et al. 2024](https://arxiv.org/abs/2412.08905)                                                                            |
+| Phi 4 Mini Instruct | 3.8B | Microsoft Research | [Microsoft 2025](https://arxiv.org/abs/2503.01743)                                           |
+| Phi 4 Mini Reasoning | 3.8B | Microsoft Research | [Xu, Peng et al. 2025](https://arxiv.org/abs/2504.21233)                                           |
+| Phi 4 Reasoning | 3.8B | Microsoft Research | [Abdin et al. 2025](https://arxiv.org/abs/2504.21318)                                           |
+| Phi 4 Reasoning Plus | 3.8B | Microsoft Research | [Abdin et al. 2025](https://arxiv.org/abs/2504.21318)                                           |
+| Platypus | 7B, 13B, 70B |  Lee et al. | [Lee, Hunter, and Ruiz 2023](https://arxiv.org/abs/2308.07317)                                                               |
+| Pythia | {14,31,70,160,410}M, {1,1.4,2.8,6.9,12}B | EleutherAI | [Biderman et al. 2023](https://arxiv.org/abs/2304.01373)                                            |
+| Qwen2.5 | 0.5B, 1.5B, 3B, 7B, 14B, 32B, 72B | Alibaba Group | [Qwen Team 2024](https://qwenlm.github.io/blog/qwen2.5/)                                               |
+| Qwen2.5 Coder | 0.5B, 1.5B, 3B, 7B, 14B, 32B | Alibaba Group | [Hui, Binyuan et al. 2024](https://arxiv.org/abs/2409.12186)                                          |
+| Qwen2.5 1M (Long Context) | 7B, 14B | Alibaba Group | [Qwen Team 2025](https://qwenlm.github.io/blog/qwen2.5-1m/)                                          |
+| Qwen2.5 Math | 1.5B, 7B, 72B | Alibaba Group | [An, Yang et al. 2024](https://arxiv.org/abs/2409.12122)                                          |
+| QwQ | 32B | Alibaba Group | [Qwen Team 2025](https://qwenlm.github.io/blog/qwq-32b/)                                                                         |
+| QwQ-Preview | 32B | Alibaba Group | [Qwen Team 2024](https://qwenlm.github.io/blog/qwq-32b-preview/)                                                                         |
+| Qwen3 | 0.6B, 1.7B, 4B, 8B, 14B, 32B | Alibaba Group | [Qwen Team 2025](https://arxiv.org/abs/2505.09388/)                                                                         |
+| Qwen3 MoE | 30B, 235B | Alibaba Group | [Qwen Team 2025](https://arxiv.org/abs/2505.09388/)                                                                         |
+| R1 Distill Llama | 8B, 70B | DeepSeek AI | [DeepSeek AI 2025](https://github.com/deepseek-ai/DeepSeek-R1/blob/main/DeepSeek_R1.pdf)                                                                                 |
+| SmolLM2 | 135M, 360M, 1.7B | Hugging Face | [Hugging Face 2024](https://github.com/huggingface/smollm)                                                               |
+| Salamandra | 2B, 7B | Barcelona Supercomputing Centre | [BSC-LTC 2024](https://github.com/BSC-LTC/salamandra)                                                                         |
+| StableCode | 3B | Stability AI | [Stability AI 2023](https://stability.ai/blog/stablecode-llm-generative-ai-coding)                                                  |
+| StableLM  | 3B, 7B | Stability AI | [Stability AI 2023](https://github.com/Stability-AI/StableLM)                                                                    |
+| StableLM Zephyr | 3B | Stability AI | [Stability AI 2023](https://stability.ai/blog/stablecode-llm-generative-ai-coding)                                             |
+| TinyLlama | 1.1B | Zhang et al. | [Zhang et al. 2023](https://github.com/jzhang38/TinyLlama)                                                                         |
+
+
+**Tip**: You can list all available models by running the `litgpt download list` command.
+
+
+</details>
+
+&nbsp;
+
+---
+
+# Workflows
+
+<p align="center">
+  <a href="#finetune-an-llm">Finetune</a> •
+  <a href="#pretrain-an-llm">Pretrain</a> •
+  <a href="#continue-pretraining-an-llm">Continued pretraining</a> •
+    <a href="#evaluate-an-llm">Evaluate</a> •
+    <a href="#deploy-an-llm">Deploy</a> •
+    <a href="#test-an-llm">Test</a>
+</p>
+
+&nbsp;
+
+Use the command line interface to run advanced workflows such as pretraining or finetuning on your own data.
+
+
+## All workflows
+After installing LitGPT, select the model and workflow to run (finetune, pretrain, evaluate, deploy, etc...):
+
+```bash
+# litgpt [action] [model]
+litgpt  serve     meta-llama/Llama-3.2-3B-Instruct
+litgpt  finetune  meta-llama/Llama-3.2-3B-Instruct
+litgpt  pretrain  meta-llama/Llama-3.2-3B-Instruct
+litgpt  chat      meta-llama/Llama-3.2-3B-Instruct
+litgpt  evaluate  meta-llama/Llama-3.2-3B-Instruct
+```
+
+&nbsp;
+
+----
+
+## Finetune an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-finetune">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/run-on-studio.svg" height="36px" alt="Run on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Finetuning is the process of taking a pretrained AI model and further training it on a smaller, specialized dataset tailored to a specific task or application.
+
+
+&nbsp;
+
+```bash
+# 0) setup your dataset
+curl -L https://huggingface.co/datasets/ksaw008/finance_alpaca/resolve/main/finance_alpaca.json -o my_custom_dataset.json
+
+# 1) Finetune a model (auto downloads weights)
+litgpt finetune microsoft/phi-2 \
+  --data JSON \
+  --data.json_path my_custom_dataset.json \
+  --data.val_split_fraction 0.1 \
+  --out_dir out/custom-model
+
+# 2) Test the model
+litgpt chat out/custom-model/final
+
+# 3) Deploy the model
+litgpt serve out/custom-model/final
+```
+
+[Read the full finetuning docs](tutorials/finetune.md)
+
+&nbsp;
+
+----
+
+## Deploy an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-serve">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/deploy-on-studios.svg" height="36px" alt="Deploy on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Deploy a pretrained or finetune LLM to use it in real-world applications. Deploy, automatically sets up a web server that can be accessed by a website or app.
+
+```bash
+# deploy an out-of-the-box LLM
+litgpt serve microsoft/phi-2
+
+# deploy your own trained model
+litgpt serve path/to/microsoft/phi-2/checkpoint
+```
+
+<details>
+  <summary>Show code to query server:</summary>
+
+&nbsp;
+
+Test the server in a separate terminal and integrate the model API into your AI product:
+```python
+# 3) Use the server (in a separate Python session)
+import requests, json
+response = requests.post(
+    "http://127.0.0.1:8000/predict",
+    json={"prompt": "Fix typos in the following sentence: Example input"}
+)
+print(response.json()["output"])
+```
+</details>
+
+[Read the full deploy docs](tutorials/deploy.md).
+
+&nbsp;
+
+----
+
+## Evaluate an LLM
+Evaluate an LLM to test its performance on various tasks to see how well it understands and generates text. Simply put, we can evaluate things like how well would it do in college-level chemistry, coding, etc... (MMLU, Truthful QA, etc...)
+
+```bash
+litgpt evaluate microsoft/phi-2 --tasks 'truthfulqa_mc2,mmlu'
+```
+
+[Read the full evaluation docs](tutorials/evaluation.md).
+
+&nbsp;
+
+----
+
+##  Test an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-chat">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/run-on-studio.svg" height="36px" alt="Run on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Test how well the model works via an interactive chat. Use the `chat` command to chat, extract embeddings, etc...
+
+Here's an example showing how to use the Phi-2 LLM:
+```bash
+litgpt chat microsoft/phi-2
+
+>> Prompt: What do Llamas eat?
+```
+
+<details>
+  <summary>Full code:</summary>
+
+&nbsp;
+
+```bash
+# 1) List all supported LLMs
+litgpt download list
+
+# 2) Use a model (auto downloads weights)
+litgpt chat microsoft/phi-2
+
+>> Prompt: What do Llamas eat?
+```
+
+The download of certain models requires an additional access token. You can read more about this in the [download](tutorials/download_model_weights.md#specific-models-and-access-tokens) documentation.
+
+</details>
+
+[Read the full chat docs](tutorials/inference.md).
+
+&nbsp;
+
+----
+
+## Pretrain an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-pretrain">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/run-on-studio.svg" height="36px" alt="Run on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Pretraining is the process of teaching an AI model by exposing it to a large amount of data before it is fine-tuned for specific tasks.
+
+<details>
+  <summary>Show code:</summary>
+
+&nbsp;
+
+```bash
+mkdir -p custom_texts
+curl https://www.gutenberg.org/cache/epub/24440/pg24440.txt --output custom_texts/book1.txt
+curl https://www.gutenberg.org/cache/epub/26393/pg26393.txt --output custom_texts/book2.txt
+
+# 1) Download a tokenizer
+litgpt download EleutherAI/pythia-160m \
+  --tokenizer_only True
+
+# 2) Pretrain the model
+litgpt pretrain EleutherAI/pythia-160m \
+  --tokenizer_dir EleutherAI/pythia-160m \
+  --data TextFiles \
+  --data.train_data_path "custom_texts/" \
+  --train.max_tokens 10_000_000 \
+  --out_dir out/custom-model
+
+# 3) Test the model
+litgpt chat out/custom-model/final
+```
+</details>
+
+[Read the full pretraining docs](tutorials/pretrain.md)
+
+&nbsp;
+
+----
+
+## Continue pretraining an LLM
+
+<div align="center">
+<a target="_blank" href="https://lightning.ai/lightning-ai/studios/litgpt-continue-pretraining">
+  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/run-on-studio.svg" height="36px" alt="Run on Studios"/>
+</a>
+</div>
+
+&nbsp;
+
+Continued pretraining is another way of finetuning that specializes an already pretrained model by training on custom data:
+
+<details>
+  <summary>Show code:</summary>
+
+&nbsp;
+
+```bash
+mkdir -p custom_texts
+curl https://www.gutenberg.org/cache/epub/24440/pg24440.txt --output custom_texts/book1.txt
+curl https://www.gutenberg.org/cache/epub/26393/pg26393.txt --output custom_texts/book2.txt
+
+# 1) Continue pretraining a model (auto downloads weights)
+litgpt pretrain EleutherAI/pythia-160m \
+  --tokenizer_dir EleutherAI/pythia-160m \
+  --initial_checkpoint_dir EleutherAI/pythia-160m \
+  --data TextFiles \
+  --data.train_data_path "custom_texts/" \
+  --train.max_tokens 10_000_000 \
+  --out_dir out/custom-model
+
+# 2) Test the model
+litgpt chat out/custom-model/final
+```
+
+</details>
+
+[Read the full continued pretraining docs](tutorials/pretrain.md#continued-pretraining-on-custom-data)
+
+&nbsp;
+
+----
+
+# State-of-the-art features
+
+✅ State-of-the-art optimizations: Flash Attention v2, multi-GPU support via fully-sharded data parallelism, [optional CPU offloading](tutorials/oom.md#do-sharding-across-multiple-gpus), and [TPU and XLA support](extensions/xla).</br>
+✅ [Pretrain](tutorials/pretrain.md), [finetune](tutorials/finetune.md), and [deploy](tutorials/inference.md)</br>
+✅ Reduce compute requirements with low-precision settings: FP16, BF16, and FP16/FP32 mixed.</br>
+✅ Lower memory requirements with [quantization](tutorials/quantize.md): 4-bit floats, 8-bit integers, and double quantization.</br>
+✅ [Configuration files](config_hub) for great out-of-the-box performance.</br>
+✅ Parameter-efficient finetuning: [LoRA](tutorials/finetune_lora.md), [QLoRA](tutorials/finetune_lora.md), [Adapter](tutorials/finetune_adapter.md), and [Adapter v2](tutorials/finetune_adapter.md).</br>
+✅ [Exporting](tutorials/convert_lit_models.md) to other popular model weight formats.</br>
+✅ Many popular datasets for [pretraining](tutorials/pretrain.md) and [finetuning](tutorials/prepare_dataset.md), and [support for custom datasets](tutorials/prepare_dataset.md#preparing-custom-datasets-for-instruction-finetuning).</br>
+✅ Readable and easy-to-modify code to experiment with the latest research ideas.</br>
+
+&nbsp;
+
+---
+
+# Training recipes
+
+LitGPT comes with validated recipes (YAML configs) to train models under different conditions.  We've generated these recipes based on the parameters we found to perform the best for different training conditions.
+
+Browse all training recipes [here](config_hub).
+
+### Example
+
+```bash
+litgpt finetune \
+  --config https://raw.githubusercontent.com/Lightning-AI/litgpt/main/config_hub/finetune/llama-2-7b/lora.yaml
+```
+<details>
+  <summary>✅ Use configs to customize training</summary>
+
+Configs let you customize training for all granular parameters like:
+
+```yaml
+# The path to the base model's checkpoint directory to load for finetuning. (type: <class 'Path'>, default: checkpoints/stabilityai/stablelm-base-alpha-3b)
+checkpoint_dir: checkpoints/meta-llama/Llama-2-7b-hf
+
+# Directory in which to save checkpoints and logs. (type: <class 'Path'>, default: out/lora)
+out_dir: out/finetune/qlora-llama2-7b
+
+# The precision to use for finetuning. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-true
+
+...
+```
+</details>
+
+<details>
+  <summary>✅ Example: LoRA finetuning config</summary>
+
+&nbsp;
+
+```yaml
+# The path to the base model's checkpoint directory to load for finetuning. (type: <class 'Path'>, default: checkpoints/stabilityai/stablelm-base-alpha-3b)
+checkpoint_dir: checkpoints/meta-llama/Llama-2-7b-hf
+
+# Directory in which to save checkpoints and logs. (type: <class 'Path'>, default: out/lora)
+out_dir: out/finetune/qlora-llama2-7b
+
+# The precision to use for finetuning. Possible choices: "bf16-true", "bf16-mixed", "32-true". (type: Optional[str], default: null)
+precision: bf16-true
+
+# If set, quantize the model with this algorithm. See ``tutorials/quantize.md`` for more information. (type: Optional[Literal['nf4', 'nf4-dq', 'fp4', 'fp4-dq', 'int8-training']], default: null)
+quantize: bnb.nf4
+
+# How many devices/GPUs to use. (type: Union[int, str], default: 1)
+devices: 1
+
+# How many nodes to use. (type: int, default: 1)
+num_nodes: 1
+
+# The LoRA rank. (type: int, default: 8)
+lora_r: 32
+
+# The LoRA alpha. (type: int, default: 16)
+lora_alpha: 16
+
+# The LoRA dropout value. (type: float, default: 0.05)
+lora_dropout: 0.05
+
+# Whether to apply LoRA to the query weights in attention. (type: bool, default: True)
+lora_query: true
+
+# Whether to apply LoRA to the key weights in attention. (type: bool, default: False)
+lora_key: false
+
+# Whether to apply LoRA to the value weights in attention. (type: bool, default: True)
+lora_value: true
+
+# Whether to apply LoRA to the output projection in the attention block. (type: bool, default: False)
+lora_projection: false
+
+# Whether to apply LoRA to the weights of the MLP in the attention block. (type: bool, default: False)
+lora_mlp: false
+
+# Whether to apply LoRA to output head in GPT. (type: bool, default: False)
+lora_head: false
+
+# Data-related arguments. If not provided, the default is ``litgpt.data.Alpaca``.
+data:
+  class_path: litgpt.data.Alpaca2k
+  init_args:
+    mask_prompt: false
+    val_split_fraction: 0.05
+    prompt_style: alpaca
+    ignore_index: -100
+    seed: 42
+    num_workers: 4
+    download_dir: data/alpaca2k
+
+# Training-related arguments. See ``litgpt.args.TrainArgs`` for details
+train:
+
+  # Number of optimizer steps between saving checkpoints (type: Optional[int], default: 1000)
+  save_interval: 200
+
+  # 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: 128)
+  global_batch_size: 8
+
+  # Number of samples per data-parallel rank (type: int, default: 4)
+  micro_batch_size: 2
+
+  # Number of iterations with learning rate warmup active (type: int, default: 100)
+  lr_warmup_steps: 10
+
+  # Number of epochs to train on (type: Optional[int], default: 5)
+  epochs: 4
+
+  # Total number of tokens to train on (type: Optional[int], default: null)
+  max_tokens:
+
+  # Limits the number of optimizer steps to run (type: Optional[int], default: null)
+  max_steps:
+
+  # Limits the length of samples (type: Optional[int], default: null)
+  max_seq_length: 512
+
+  # Whether to tie the embedding weights with the language modeling head weights (type: Optional[bool], default: null)
+  tie_embeddings:
+
+  #   (type: float, default: 0.0003)
+  learning_rate: 0.0002
+
+  #   (type: float, default: 0.02)
+  weight_decay: 0.0
+
+  #   (type: float, default: 0.9)
+  beta1: 0.9
+
+  #   (type: float, default: 0.95)
+  beta2: 0.95
+
+  #   (type: Optional[float], default: null)
+  max_norm:
+
+  #   (type: float, default: 6e-05)
+  min_lr: 6.0e-05
+
+# Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details
+eval:
+
+  # Number of optimizer steps between evaluation calls (type: int, default: 100)
+  interval: 100
+
+  # Number of tokens to generate (type: Optional[int], default: 100)
+  max_new_tokens: 100
+
+  # Number of iterations (type: int, default: 100)
+  max_iters: 100
+
+# The name of the logger to send metrics to. (type: Literal['wandb', 'tensorboard', 'csv'], default: csv)
+logger_name: csv
+
+# The random seed to use for reproducibility. (type: int, default: 1337)
+seed: 1337
+```
+</details>
+
+<details>
+  <summary>✅ Override any parameter in the CLI:</summary>
+
+```bash
+litgpt finetune \
+  --config https://raw.githubusercontent.com/Lightning-AI/litgpt/main/config_hub/finetune/llama-2-7b/lora.yaml \
+  --lora_r 4
+```
+</details>
+
+&nbsp;
+
+----
+
+# Project highlights
+
+LitGPT powers many great AI projects, initiatives, challenges and of course enterprises. Please submit a pull request to be considered for a feature.
+
+<details>
+  <summary>📊 SAMBA: Simple Hybrid State Space Models for Efficient Unlimited Context Language Modeling</summary>
+
+The [Samba](https://github.com/microsoft/Samba) project by researchers at Microsoft is built on top of the LitGPT code base and combines state space models with sliding window attention, which outperforms pure state space models.
+
+</details>
+
+<details>
+  <summary>🏆 NeurIPS 2023 Large Language Model Efficiency Challenge: 1 LLM + 1 GPU + 1 Day</summary>
+
+The LitGPT repository was the official starter kit for the [NeurIPS 2023 LLM Efficiency Challenge](https://llm-efficiency-challenge.github.io), which is a competition focused on finetuning an existing non-instruction tuned LLM for 24 hours on a single GPU.
+
+</details>
+
+<details>
+  <summary>🦙 TinyLlama: An Open-Source Small Language Model</summary>
+
+
+LitGPT powered the [TinyLlama project](https://github.com/jzhang38/TinyLlama) and [TinyLlama: An Open-Source Small Language Model](https://arxiv.org/abs/2401.02385) research paper.
+
+</details>
+
+<details>
+  <summary>🍪 MicroLlama: MicroLlama-300M</summary>
+
+[MicroLlama](https://github.com/keeeeenw/MicroLlama) is a 300M Llama model pretrained on 50B tokens powered by TinyLlama and LitGPT.
+</details>
+
+<details>
+  <summary>🔬 Pre-training Small Base LMs with Fewer Tokens</summary>
+
+The research paper ["Pre-training Small Base LMs with Fewer Tokens"](https://arxiv.org/abs/2404.08634), which utilizes LitGPT, develops smaller base language models by inheriting a few transformer blocks from larger models and training on a tiny fraction of the data used by the larger models. It demonstrates that these smaller models can perform comparably to larger models despite using significantly less training data and resources.
+
+</details>
+
+&nbsp;
+
+----
+
+# Community
+
+We welcome all individual contributors, regardless of their level of experience or hardware. Your contributions are valuable, and we are excited to see what you can accomplish in this collaborative and supportive environment.
+
+- [Request a feature](https://github.com/Lightning-AI/litgpt/issues)
+- [Submit your first contribution](https://lightning.ai/pages/community/tutorial/how-to-contribute-to-litgpt/)
+- [Join our Discord](https://discord.gg/VptPCZkGNa)
+
+&nbsp;
+
+# Tutorials
+
+🚀 [Get started](tutorials/0_to_litgpt.md)</br>
+⚡️ [Finetuning, incl. LoRA, QLoRA, and Adapters](tutorials/finetune.md)</br>
+🤖 [Pretraining](tutorials/pretrain.md)</br>
+💬 [Model evaluation](tutorials/evaluation.md)</br>
+📘 [Supported and custom datasets](tutorials/prepare_dataset.md)</br>
+🧹 [Quantization](tutorials/quantize.md)</br>
+🤯 [Tips for dealing with out-of-memory (OOM) errors](tutorials/oom.md)</br>
+🧑🏽‍💻 [Using cloud TPUs](extensions/xla)</br>
+
+&nbsp;
+
+----
+
+### Acknowledgments
+
+This implementation extends on [Lit-LLaMA](https://github.com/lightning-AI/lit-llama) and [nanoGPT](https://github.com/karpathy/nanoGPT), and it's **powered by [Lightning Fabric](https://lightning.ai/docs/fabric/stable/) ⚡**.
+
+- [@karpathy](https://github.com/karpathy) for [nanoGPT](https://github.com/karpathy/nanoGPT)
+- [@EleutherAI](https://github.com/EleutherAI) for [GPT-NeoX](https://github.com/EleutherAI/gpt-neox) and the [Evaluation Harness](https://github.com/EleutherAI/lm-evaluation-harness)
+- [@TimDettmers](https://github.com/TimDettmers) for [bitsandbytes](https://github.com/TimDettmers/bitsandbytes)
+- [@Microsoft](https://github.com/microsoft) for [LoRA](https://github.com/microsoft/LoRA)
+- [@tridao](https://github.com/tridao) for [Flash Attention 2](https://github.com/Dao-AILab/flash-attention)
+
+### License
+
+LitGPT is released under the [Apache 2.0](https://github.com/Lightning-AI/litgpt/blob/main/LICENSE) license.
+
+### Citation
+
+If you use LitGPT in your research, please cite the following work:
+
+```bibtex
+@misc{litgpt-2023,
+  author       = {Lightning AI},
+  title        = {LitGPT},
+  howpublished = {\url{https://github.com/Lightning-AI/litgpt}},
+  year         = {2023},
+}
+```
+
+&nbsp;

litgpt.egg-info/SOURCES.txt

@@ -0,0 +1,89 @@
+LICENSE
+README.md
+pyproject.toml
+litgpt/__init__.py
+litgpt/__main__.py
+litgpt/adapter.py
+litgpt/adapter_v2.py
+litgpt/api.py
+litgpt/args.py
+litgpt/config.py
+litgpt/lora.py
+litgpt/model.py
+litgpt/pretrain.py
+litgpt/prompts.py
+litgpt/tokenizer.py
+litgpt/utils.py
+litgpt.egg-info/PKG-INFO
+litgpt.egg-info/SOURCES.txt
+litgpt.egg-info/dependency_links.txt
+litgpt.egg-info/entry_points.txt
+litgpt.egg-info/requires.txt
+litgpt.egg-info/top_level.txt
+litgpt/chat/__init__.py
+litgpt/chat/base.py
+litgpt/data/__init__.py
+litgpt/data/alpaca.py
+litgpt/data/alpaca_2k.py
+litgpt/data/alpaca_gpt4.py
+litgpt/data/base.py
+litgpt/data/deita.py
+litgpt/data/flan.py
+litgpt/data/json_data.py
+litgpt/data/lima.py
+litgpt/data/lit_data.py
+litgpt/data/longform.py
+litgpt/data/microllama.py
+litgpt/data/openwebtext.py
+litgpt/data/prepare_slimpajama.py
+litgpt/data/prepare_starcoder.py
+litgpt/data/text_files.py
+litgpt/data/tinyllama.py
+litgpt/data/tinystories.py
+litgpt/deploy/__init__.py
+litgpt/deploy/serve.py
+litgpt/eval/evaluate.py
+litgpt/finetune/__init__.py
+litgpt/finetune/adapter.py
+litgpt/finetune/adapter_v2.py
+litgpt/finetune/full.py
+litgpt/finetune/lora.py
+litgpt/generate/__init__.py
+litgpt/generate/adapter.py
+litgpt/generate/adapter_v2.py
+litgpt/generate/base.py
+litgpt/generate/full.py
+litgpt/generate/sequentially.py
+litgpt/generate/speculative_decoding.py
+litgpt/generate/tp.py
+litgpt/scripts/__init__.py
+litgpt/scripts/convert_hf_checkpoint.py
+litgpt/scripts/convert_lit_checkpoint.py
+litgpt/scripts/convert_pretrained_checkpoint.py
+litgpt/scripts/download.py
+litgpt/scripts/merge_lora.py
+tests/test_adapter.py
+tests/test_adapter_v2.py
+tests/test_api.py
+tests/test_args.py
+tests/test_batch.py
+tests/test_chat.py
+tests/test_ci.py
+tests/test_cli.py
+tests/test_config.py
+tests/test_config_hub.py
+tests/test_distributed.py
+tests/test_evaluate.py
+tests/test_full.py
+tests/test_generate_speculatively.py
+tests/test_lora.py
+tests/test_merge_lora.py
+tests/test_model.py
+tests/test_pretrain.py
+tests/test_prompts.py
+tests/test_readme.py
+tests/test_rope.py
+tests/test_serve.py
+tests/test_tokenizer.py
+tests/test_trainer_support.py
+tests/test_utils.py

litgpt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

litgpt.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+litgpt = litgpt.__main__:main

litgpt.egg-info/requires.txt

@@ -0,0 +1,51 @@
+huggingface-hub<0.33,>=0.23.5
+lightning>=2.5
+psutil==7
+safetensors>=0.4.3
+tokenizers>=0.15.2
+torch>=2.5
+tqdm>=4.66
+
+[:python_version <= "3.9"]
+jsonargparse[signatures]<=4.32.1,>=4.30.1
+
+[:python_version > "3.9"]
+jsonargparse[signatures]>=4.37
+
+[compiler]
+
+[compiler:python_version >= "3.10" and sys_platform == "linux"]
+lightning-thunder>=0.2.0.dev20250119
+
+[extra]
+datasets<4,>=2.18
+huggingface-hub[hf-transfer]>=0.21
+litdata==0.2.51
+litserve>0.2
+lm-eval>=0.4.2
+pandas>=1.9
+pyarrow>=15.0.2
+requests>=2.31
+sentencepiece>=0.2
+tensorboard>=2.14
+torchmetrics>=1.3.1
+transformers<4.52,>=4.51.3
+zstandard>=0.22
+
+[extra:sys_platform != "win32"]
+uvloop>=0.2
+
+[extra:sys_platform == "darwin"]
+bitsandbytes<0.43,>=0.42
+
+[extra:sys_platform == "linux" or sys_platform == "win32"]
+bitsandbytes<0.45.5,>=0.45.2
+
+[test]
+einops>=0.7
+protobuf>=4.23.4
+pytest>=8.1.1
+pytest-benchmark>=5.1
+pytest-dependency>=0.6
+pytest-rerunfailures>=14
+pytest-timeout>=2.3.1

litgpt.egg-info/top_level.txt

@@ -0,0 +1 @@
+litgpt

litgpt/__init__.py

@@ -0,0 +1,20 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import logging
+import re
+
+from litgpt.api import LLM
+from litgpt.config import Config
+from litgpt.model import GPT  # needs to be imported before config
+from litgpt.prompts import PromptStyle
+from litgpt.tokenizer import Tokenizer
+
+# Suppress excessive warnings, see https://github.com/pytorch/pytorch/issues/111632
+pattern = re.compile(".*Profiler function .* will be ignored")
+logging.getLogger("torch._dynamo.variables.torch").addFilter(lambda record: not pattern.search(record.getMessage()))
+
+# Avoid printing state-dict profiling output at the WARNING level when saving a checkpoint
+logging.getLogger("torch.distributed.fsdp._optim_utils").disabled = True
+logging.getLogger("torch.distributed.fsdp._debug_utils").disabled = True
+
+__all__ = ["LLM", "GPT", "Config", "PromptStyle", "Tokenizer"]

litgpt/__main__.py

@@ -0,0 +1,75 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import warnings
+
+import torch
+from jsonargparse import CLI, set_config_read_mode, set_docstring_parse_options
+
+from litgpt.chat.base import main as chat_fn
+from litgpt.deploy.serve import run_server as serve_fn
+from litgpt.eval.evaluate import convert_and_evaluate as evaluate_fn
+from litgpt.finetune.adapter import setup as finetune_adapter_fn
+from litgpt.finetune.adapter_v2 import setup as finetune_adapter_v2_fn
+from litgpt.finetune.full import setup as finetune_full_fn
+from litgpt.finetune.lora import setup as finetune_lora_fn
+from litgpt.generate.adapter import main as generate_adapter_fn
+from litgpt.generate.adapter_v2 import main as generate_adapter_v2_fn
+from litgpt.generate.base import main as generate_base_fn
+from litgpt.generate.full import main as generate_full_fn
+from litgpt.generate.sequentially import main as generate_sequentially_fn
+from litgpt.generate.speculative_decoding import main as generate_speculatively_fn
+from litgpt.generate.tp import main as generate_tp_fn
+from litgpt.pretrain import setup as pretrain_fn
+from litgpt.perplexity import setup as perplexity_fn
+from litgpt.scripts.convert_hf_checkpoint import convert_hf_checkpoint as convert_hf_checkpoint_fn
+from litgpt.scripts.convert_lit_checkpoint import convert_lit_checkpoint as convert_lit_checkpoint_fn
+from litgpt.scripts.convert_pretrained_checkpoint import (
+    convert_pretrained_checkpoint as convert_pretrained_checkpoint_fn,
+)
+from litgpt.scripts.download import download_from_hub as download_fn
+from litgpt.scripts.merge_lora import merge_lora as merge_lora_fn
+
+
+def main() -> None:
+    parser_data = {
+        "download": download_fn,
+        "chat": chat_fn,
+        "finetune": finetune_lora_fn,
+        "finetune_lora": finetune_lora_fn,
+        "finetune_full": finetune_full_fn,
+        "finetune_adapter": finetune_adapter_fn,
+        "finetune_adapter_v2": finetune_adapter_v2_fn,
+        "pretrain": pretrain_fn,
+        "perplexity": perplexity_fn,
+        "generate": generate_base_fn,
+        "generate_full": generate_full_fn,
+        "generate_adapter": generate_adapter_fn,
+        "generate_adapter_v2": generate_adapter_v2_fn,
+        "generate_sequentially": generate_sequentially_fn,
+        "generate_speculatively": generate_speculatively_fn,
+        "generate_tp": generate_tp_fn,
+        "convert_to_litgpt": convert_hf_checkpoint_fn,
+        "convert_from_litgpt": convert_lit_checkpoint_fn,
+        "convert_pretrained_checkpoint": convert_pretrained_checkpoint_fn,
+        "merge_lora": merge_lora_fn,
+        "evaluate": evaluate_fn,
+        "serve": serve_fn,
+    }
+
+    set_docstring_parse_options(attribute_docstrings=True)
+    set_config_read_mode(urls_enabled=True)
+
+    # PyTorch bug that raises a false-positive warning
+    # More info: https://github.com/Lightning-AI/litgpt/issues/1561
+    warning_message = r"The epoch parameter in `scheduler.step\(\)` was not necessary and is being deprecated.*"
+
+    warnings.filterwarnings(
+        action="ignore", message=warning_message, category=UserWarning, module=r".*torch\.optim\.lr_scheduler.*"
+    )
+
+    torch.set_float32_matmul_precision("high")
+    CLI(parser_data)
+
+
+if __name__ == "__main__":
+    main()

litgpt/adapter.py

@@ -0,0 +1,129 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+"""Implementation of the paper:
+
+LLaMA-Adapter: Efficient Fine-tuning of Language Models with Zero-init Attention
+https://arxiv.org/abs/2303.16199
+
+Port for LitGPT
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple
+
+import torch
+import torch.nn as nn
+from typing_extensions import Self
+
+from litgpt.config import Config as BaseConfig
+from litgpt.model import GPT as BaseModel
+from litgpt.model import Block as BaseBlock
+from litgpt.model import CausalSelfAttention as BaseCausalSelfAttention
+
+
+@dataclass
+class Config(BaseConfig):
+    adapter_prompt_length: int = 10
+    adapter_start_layer: int = 2
+
+
+class GPT(BaseModel):
+    # Copy & paste from :class:`model.GPT`. Note that :class:`Block` is new here.
+    def __init__(self, config: Config) -> None:
+        nn.Module.__init__(self)
+        assert config.padded_vocab_size is not None
+        self.config = config
+
+        self.lm_head = nn.Linear(config.n_embd, config.padded_vocab_size, bias=config.lm_head_bias)
+        self.transformer = nn.ModuleDict(
+            dict(
+                wte=nn.Embedding(config.padded_vocab_size, config.n_embd),
+                h=nn.ModuleList(Block(config, block_idx) for block_idx in range(config.n_layer)),
+                ln_f=config.norm_class(config.n_embd, eps=config.norm_eps),
+            )
+        )
+        self.mask_cache: Optional[torch.Tensor] = None
+        self.max_seq_length = self.config.block_size
+
+    @classmethod
+    def from_name(cls, name: str, **kwargs: Any) -> Self:
+        return cls(Config.from_name(name, **kwargs))
+
+    def _init_weights(self, module: nn.Module) -> None:
+        """Meant to be used with `gpt.apply(gpt._init_weights)`. Unused method left for completeness."""
+        super()._init_weights(module)
+        if isinstance(module, CausalSelfAttention):
+            module.reset_parameters()
+
+
+class Block(BaseBlock):
+    def __init__(self, config: Config, block_idx: int) -> None:
+        super().__init__(config, block_idx)
+        self.attn = CausalSelfAttention(config, block_idx)
+
+
+class CausalSelfAttention(BaseCausalSelfAttention):
+    """A modification of `litgpt.model.CausalSelfAttention` that adds the attention
+    over the adaption prompt."""
+
+    def __init__(self, config: Config, block_idx: int) -> None:
+        super().__init__(config, block_idx)
+        if block_idx >= config.adapter_start_layer:
+            # adapter embedding layer
+            self.adapter_wte = nn.Embedding(config.adapter_prompt_length, config.n_embd)
+            # gate for adaption
+            self.gating_factor = torch.nn.Parameter(torch.zeros(1, 1, config.n_head, 1))
+            # kv cache for inference
+            self.adapter_kv_cache: Optional[Tuple[torch.Tensor, torch.Tensor]] = None
+
+    def scaled_dot_product_attention(
+        self, q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, mask: Optional[torch.Tensor] = None
+    ) -> torch.Tensor:
+        y = super().scaled_dot_product_attention(q, k, v, mask)
+        if self.block_idx < self.config.adapter_start_layer:
+            return y
+
+        aT = self.config.adapter_prompt_length
+        if self.adapter_kv_cache is not None:
+            # since this uses the wte weights as the prefix and the kv cache is only used during inference, ak and av
+            # are the same every call
+            ak, av = self.adapter_kv_cache
+        else:
+            prefix = self.adapter_wte.weight.reshape(1, aT, self.config.n_embd)
+            aqkv = self.qkv(prefix)
+            q_per_kv = self.config.n_head // self.config.n_query_groups
+            aqkv = aqkv.view(1, aT, self.config.n_query_groups, q_per_kv + 2, self.config.head_size)
+            aqkv = aqkv.permute(0, 2, 3, 1, 4)
+            _, ak, av = aqkv.split((q_per_kv, 1, 1), dim=2)
+            if self.config.n_query_groups != 1:
+                # for MHA this is a no-op
+                ak = ak.repeat_interleave(q_per_kv, dim=2)
+                av = av.repeat_interleave(q_per_kv, dim=2)
+            ak = ak.view(1, -1, aT, self.config.head_size)  # (1, nh_ak, aT, hs)
+            av = av.view(1, -1, aT, self.config.head_size)  # (1, nh_av, aT, hs)
+            self.adapter_kv_cache = (ak, av)
+
+        T = q.size(2)
+        amask = torch.ones(T, aT, dtype=torch.bool, device=q.device)
+        ay = super().scaled_dot_product_attention(q, ak, av, amask)
+        return y + self.gating_factor * ay
+
+    def reset_parameters(self) -> None:
+        if hasattr(self, "gating_factor"):
+            torch.nn.init.zeros_(self.gating_factor)
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with older checkpoints."""
+        if (key := prefix + "gating_factor") in state_dict and state_dict[key].size(1) == self.config.n_head:
+            state_dict[key] = state_dict[key].permute(0, 2, 1, 3)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+def mark_only_adapter_as_trainable(model: GPT) -> None:
+    """Sets `requires_grad=False` for all non-adapter weights."""
+    for name, param in model.named_parameters():
+        param.requires_grad = adapter_filter(name, param)
+
+
+def adapter_filter(key: str, value: Any) -> bool:
+    return "adapter_wte" in key or "gating_factor" in key

litgpt/adapter_v2.py

@@ -0,0 +1,210 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+"""Implementation of the paper:
+
+LLaMA-Adapter V2: Parameter-Efficient Visual Instruction Model
+https://arxiv.org/abs/2304.15010
+
+Port for LitGPT
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Type
+
+import torch
+import torch.nn as nn
+from typing_extensions import Self
+
+import litgpt
+from litgpt.adapter import GPT as BaseModel
+from litgpt.adapter import CausalSelfAttention as BaseCausalSelfAttention
+from litgpt.adapter import Config as BaseConfig
+from litgpt.model import Block as BaseBlock
+from litgpt.scripts.convert_hf_checkpoint import qkv_reassemble
+from litgpt.utils import map_old_state_dict_weights
+
+
+@dataclass
+class Config(BaseConfig):
+    @property
+    def mlp_class(self) -> Type:
+        return getattr(litgpt.adapter_v2, self.mlp_class_name)
+
+
+def adapter_filter(key: str, value: Any) -> bool:
+    adapter_substrings = (
+        # regular adapter v1 parameters
+        "adapter_wte",
+        "gating_factor",
+        # adapter v2: new bias and scale used in Linear
+        "adapter_scale",
+        "adapter_bias",
+        # adapter v2: Norm parameters are now trainable
+        "norm_1",
+        "norm_2",
+        "ln_f",
+    )
+    return any(s in key for s in adapter_substrings)
+
+
+class AdapterV2Linear(torch.nn.Module):
+    def __init__(self, in_features: int, out_features: int, **kwargs) -> None:
+        super().__init__()
+        self.linear = torch.nn.Linear(in_features, out_features, **kwargs)
+        self.adapter_bias = torch.nn.Parameter(torch.zeros(out_features), requires_grad=False)
+        self.adapter_scale = torch.nn.Parameter(torch.ones(out_features), requires_grad=False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.adapter_scale * (self.linear(x) + self.adapter_bias)
+
+    def reset_parameters(self) -> None:
+        nn.init.zeros_(self.adapter_bias)
+        nn.init.ones_(self.adapter_scale)
+
+
+class GPT(BaseModel):
+    # Copy & paste from :class:`model.GPT`. Note that :class:`Block` is new here.
+    def __init__(self, config: Config) -> None:
+        nn.Module.__init__(self)
+        assert config.padded_vocab_size is not None
+        self.config = config
+
+        self.lm_head = AdapterV2Linear(config.n_embd, config.padded_vocab_size, bias=config.lm_head_bias)
+        self.transformer = nn.ModuleDict(
+            dict(
+                wte=nn.Embedding(config.padded_vocab_size, config.n_embd),
+                h=nn.ModuleList(Block(config, block_idx) for block_idx in range(config.n_layer)),
+                ln_f=config.norm_class(config.n_embd, eps=config.norm_eps),
+            )
+        )
+        self.mask_cache: Optional[torch.Tensor] = None
+        self.max_seq_length = self.config.block_size
+
+    @classmethod
+    def from_name(cls, name: str, **kwargs: Any) -> Self:
+        return cls(Config.from_name(name, **kwargs))
+
+    def _init_weights(self, module: nn.Module) -> None:
+        """Meant to be used with `gpt.apply(gpt._init_weights)`. Unused method left for completeness."""
+        super()._init_weights(module)
+        if isinstance(module, AdapterV2Linear):
+            module.reset_parameters()
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base checkpoints."""
+        mapping = {"lm_head.weight": "lm_head.linear.weight", "lm_head.bias": "lm_head.linear.bias"}
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+class Block(BaseBlock):
+    def __init__(self, config: Config, block_idx: int) -> None:
+        super().__init__(config, block_idx)
+        self.attn = CausalSelfAttention(config, block_idx)
+        self.mlp = config.mlp_class(config)
+
+
+class CausalSelfAttention(BaseCausalSelfAttention):
+    """A modification of `litgpt.adapter.CausalSelfAttention` that uses the Adapter V2 Linear class"""
+
+    # Copy&paste from :class:`model.CausalSelfAttention`
+    def __init__(self, config: Config, block_idx: int) -> None:
+        super().__init__(config, block_idx)
+        # key, query, value projections for all heads, but in a batch
+        shape = (config.n_head + 2 * config.n_query_groups) * config.head_size
+        self.qkv = AdapterV2Linear(in_features=config.n_embd, out_features=shape, bias=config.bias or config.attn_bias)
+        # output projection
+        self.proj = AdapterV2Linear(config.head_size * config.n_head, config.n_embd, bias=config.bias)
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base and/or legacy checkpoints."""
+        mapping = {
+            "qkv.weight": "qkv.linear.weight",
+            "qkv.bias": "qkv.linear.bias",
+            "proj.weight": "proj.linear.weight",
+            "proj.bias": "proj.linear.bias",
+        }
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        # For compatibility with older checkpoints
+        if (key := prefix + "gating_factor") in state_dict and state_dict[key].size(1) == self.config.n_head:
+            state_dict[key] = state_dict[key].permute(0, 2, 1, 3)
+
+        for attr in ("weight", "bias"):
+            legacy_key = f"{prefix}attn.linear.{attr}"
+            current_key = f"{prefix}qkv.linear.{attr}"
+            if legacy_key in state_dict:
+                state_dict[current_key] = qkv_reassemble(state_dict.pop(legacy_key), self.config)
+
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+class GptNeoxMLP(litgpt.model.GptNeoxMLP):
+    def __init__(self, config: Config) -> None:
+        nn.Module.__init__(self)
+        self.fc = AdapterV2Linear(config.n_embd, config.intermediate_size, bias=config.bias)
+        self.proj = AdapterV2Linear(config.intermediate_size, config.n_embd, bias=config.bias)
+        self.config = config
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base checkpoints."""
+        mapping = {
+            "fc.weight": "fc.linear.weight",
+            "fc.bias": "fc.linear.bias",
+            "proj.weight": "proj.linear.weight",
+            "proj.bias": "proj.linear.bias",
+        }
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+class LLaMAMLP(litgpt.model.LLaMAMLP):
+    def __init__(self, config: Config, intermediate_size: Optional[int] = None) -> None:
+        nn.Module.__init__(self)
+        self.intermediate_size = intermediate_size or config.intermediate_size
+        self.fc_1 = AdapterV2Linear(config.n_embd, self.intermediate_size, bias=config.bias)
+        self.fc_2 = AdapterV2Linear(config.n_embd, self.intermediate_size, bias=config.bias)
+        self.proj = AdapterV2Linear(self.intermediate_size, config.n_embd, bias=config.bias)
+        self.config = config
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base checkpoints."""
+        mapping = {
+            "fc_1.weight": "fc_1.linear.weight",
+            "fc_1.bias": "fc_1.linear.bias",
+            "fc_2.weight": "fc_2.linear.weight",
+            "fc_2.bias": "fc_2.linear.bias",
+            "proj.weight": "proj.linear.weight",
+            "proj.bias": "proj.linear.bias",
+        }
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+class GemmaMLP(LLaMAMLP):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x_fc_1 = self.fc_1(x)
+        x_fc_2 = self.fc_2(x)
+        x = torch.nn.functional.gelu(x_fc_1, approximate=self.config.gelu_approximate) * x_fc_2
+        return self.proj(x)
+
+
+class LLaMAMoE(litgpt.model.LLaMAMoE):
+    def __init__(self, config: Config) -> None:
+        nn.Module.__init__(self)
+        self.gate = AdapterV2Linear(config.n_embd, config.n_expert, bias=False)
+        self.experts = nn.ModuleList(
+            LLaMAMLP(config, intermediate_size=config.moe_intermediate_size) for _ in range(config.n_expert)
+        )
+        self.config = config
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base checkpoints."""
+        mapping = {"gate.weight": "gate.linear.weight"}
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+def mark_only_adapter_v2_as_trainable(model: GPT) -> None:
+    """Sets requires_grad=False for all non-adapter weights"""
+    for name, param in model.named_parameters():
+        param.requires_grad = adapter_filter(name, param)

litgpt/api.py

@@ -0,0 +1,734 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+#
+# This file implements the LitGPT Python API
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable, List, Literal, Optional, Tuple, Union
+
+import lightning as L
+import numpy as np
+import torch
+from lightning.fabric.accelerators import CUDAAccelerator
+from lightning.fabric.plugins import BitsandbytesPrecision
+from tqdm import tqdm
+
+from litgpt.chat.base import generate as stream_generate_fn
+from litgpt.config import Config, name_to_config
+from litgpt.generate.base import generate as generate_fn
+from litgpt.generate.sequentially import sequential
+from litgpt.generate.tp import tensor_parallel
+from litgpt.model import GPT
+from litgpt.prompts import PromptStyle, has_prompt_style, load_prompt_style, save_prompt_style
+from litgpt.tokenizer import Tokenizer
+from litgpt.utils import (
+    auto_download_checkpoint,
+    check_file_size_on_cpu_and_warn,
+    check_nvlink_connectivity,
+    chunked_cross_entropy,
+    copy_config_files,
+    extend_checkpoint_dir,
+    get_default_supported_precision,
+    load_checkpoint,
+    save_config,
+)
+
+
+class LLM(torch.nn.Module):
+    def __init__(
+        self,
+        model: GPT,
+        preprocessor=None,
+        prompt_style: PromptStyle = None,
+        devices: Union[int, List[int]] = None,
+        config: Config = None,
+        checkpoint_dir: Path = None,
+        fabric: L.Fabric = None,
+        generate_strategy: Optional[Literal["sequential", "tensor_parallel"]] = None,
+        kv_cache_initialized: bool = False,
+        fixed_kv_cache_size: Union[int, Literal["max_model_supported"], None] = None,
+    ) -> None:
+        super().__init__()
+        self.model = model
+        self.preprocessor = preprocessor
+        self.devices = devices
+        self.prompt_style = prompt_style
+        self.config = config
+        self.checkpoint_dir = checkpoint_dir
+        self.fabric = fabric
+        self.generate_strategy = generate_strategy
+        self.kv_cache_initialized = kv_cache_initialized
+        self.fixed_kv_cache_size = fixed_kv_cache_size
+        self.prev_generated_seq_length = 0
+
+    """
+    LLM model class for inference, pretraining, and finetuning.
+
+    Example:
+        from litgpt.api import LLM
+
+        llm = LLM.load("microsoft/phi-2")
+        text = llm.generate("What do Llamas eat?", top_k=1)
+        print(text)
+    """
+
+    @property
+    def tokenizer(self):
+        return self.preprocessor.tokenizer
+
+    def state_dict(self, destination=None, prefix="", keep_vars=False):
+        return self.model.state_dict(destination=destination, prefix=prefix, keep_vars=keep_vars)
+
+    def load_state_dict(self, state_dict, strict=True):
+        return self.model.load_state_dict(state_dict, strict=strict)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        target_ids: Optional[torch.Tensor] = None,
+        loss_fn: Optional[Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None,
+    ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+        logits = self.model(input_ids)
+        if target_ids is not None:
+            if loss_fn is None:
+                loss_fn = chunked_cross_entropy
+            loss = loss_fn(logits[..., :-1, :], target_ids[..., 1:])
+            return logits, loss
+        else:
+            return logits
+
+    def trainer_setup(self, trainer_ckpt: Optional[Path] = None) -> None:
+        """Initializes the model checkpoint for PyTorch Lightning Trainer contexts"""
+        self.model = GPT(self.config)
+
+        if trainer_ckpt is not None:
+            # strip the object name key from the state_dict
+            state_dict = torch.load(trainer_ckpt, weights_only=True)["state_dict"]
+            first_key = next(iter(state_dict))
+            prefix = first_key.split(".")[0] + "."
+            keys_to_modify = [key for key in state_dict if key.startswith(prefix)]
+            for key in keys_to_modify:
+                new_key = key.replace(prefix, "", 1)
+                state_dict[new_key] = state_dict.pop(key)
+
+            self.load_state_dict(state_dict, strict=True)
+
+        elif self.checkpoint_dir is not None:
+            state_dict = torch.load(self.checkpoint_dir / "lit_model.pth", weights_only=False)
+            self.load_state_dict(state_dict, strict=False)
+
+        else:
+            raise ValueError(
+                "No checkpoint found. Either provide a valid path via `trainer_ckpt` "
+                "or ensure that `self.checkpoint_dir` points to a folder containing a `lit_model.pth` weight file."
+            )
+
+    def save(self, out_dir: Optional[Path] = None, prompt_style: Optional[PromptStyle] = None) -> None:
+        out_dir = Path(out_dir)
+        save_path = out_dir / "lit_model.pth"
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if prompt_style is None:
+            prompt_style = PromptStyle.from_config(self.config)
+        if self.fabric is None:
+            torch.save(self.state_dict(), save_path)
+        else:
+            self.fabric.save(save_path, self.state_dict())
+
+        if self.fabric is None or self.fabric.global_rank == 0:
+            # If initialization a model with random weights, the checkpoint dir can be none
+            if self.checkpoint_dir is not None:
+                copy_config_files(Path(self.checkpoint_dir), save_path.parent)
+            else:
+                save_config(self.config, out_dir)
+
+            save_prompt_style(prompt_style, save_path.parent)
+
+    @classmethod
+    def load(
+        cls,
+        model: str,
+        init: Optional[Literal["pretrained", "random"]] = "pretrained",
+        tokenizer_dir: Optional[Path] = None,
+        access_token: Optional[str] = None,
+        distribute: Optional[Literal["auto"]] = "auto",
+    ) -> "LLM":
+        """
+        Loads the LLM from a local directory or model hub.
+
+        Arguments
+            model: A local path to a directory containing the model weights or a valid model name.
+               You can get a list of valid model names via the `litgpt download list` command line argument.
+            init: If "pretrained" (default), downloads the model from the HF Hub if a local model can't be found at the `model`
+                directory name; otherwise loads the model from the local directory.
+                If "random", initializes the `model` with random weights.
+            tokenizer_dir: An optional tokenizer directory if `model` is not a checkpoint directory, or if a user
+                wants to use a different tokenizer instead.
+            access_token: Optional API token to access models with restrictions when using `init="pretrained"`.
+            distribute: If "auto" (default), initializes the model on a single GPU if available and otherwise on the CPU.
+                To have more control over the model distribution strategy and utilize multiple GPUs, you can set
+                `llm = LLM.load(..., distribute=None)` and call `llm.distribute(...)` manually.
+        """
+
+        allowed_init = {"pretrained", "random"}
+
+        if init == "pretrained":
+            checkpoint_dir = auto_download_checkpoint(
+                model_name=model, access_token=access_token, ignore_tokenizer_files=tokenizer_dir is not None
+            )
+            config = Config.from_file(checkpoint_dir / "model_config.yaml")
+
+        elif init == "random":
+            checkpoint_dir = None
+            try:
+                config = Config.from_name(model)
+            except ValueError:
+                print(f"Model name {model} is not supported.\n")
+                available_models = "\n".join(sorted(name_to_config))
+                print(f"Available values:\n{available_models}")
+                return
+
+        else:
+            raise ValueError(f"Invalid init option: {init}. Must be one of {allowed_init}")
+
+        torch.set_float32_matmul_precision("high")
+
+        if tokenizer_dir is not None:
+            tokenizer_dir = extend_checkpoint_dir(Path(tokenizer_dir))
+            tokenizer = Tokenizer(tokenizer_dir)
+        elif checkpoint_dir is not None:
+            tokenizer = Tokenizer(checkpoint_dir)
+        else:
+            raise ValueError("Provide a path to a tokenizer directory via the `tokenizer_dir` setting.")
+
+        if checkpoint_dir is not None:
+            prompt_style = (
+                load_prompt_style(checkpoint_dir)
+                if has_prompt_style(checkpoint_dir)
+                else PromptStyle.from_config(config)
+            )
+        else:
+            prompt_style = PromptStyle.from_config(config)
+
+        if distribute == "auto":
+            if torch.cuda.is_available():
+                accelerator = "cuda"
+            elif torch.backends.mps.is_available():
+                accelerator = "mps"
+            else:
+                accelerator = "cpu"
+
+            fabric = L.Fabric(
+                accelerator=accelerator,
+                devices=1,
+                precision=get_default_supported_precision(training=False),
+            )
+
+            with fabric.init_module(empty_init=False):
+                model = GPT(config)
+            model.eval()
+            preprocessor = Preprocessor(tokenizer, device=fabric.device)
+
+            if checkpoint_dir is not None:
+                checkpoint_path = checkpoint_dir / "lit_model.pth"
+                check_file_size_on_cpu_and_warn(checkpoint_path, fabric.device)
+                load_checkpoint(fabric, model, checkpoint_path)
+
+            model = fabric.setup_module(model)
+
+        else:
+            preprocessor = Preprocessor(tokenizer, device="cuda" if torch.cuda.is_available() else "cpu")
+            model = None
+            fabric = None
+
+        return cls(
+            model=model,
+            preprocessor=preprocessor,
+            prompt_style=prompt_style,
+            config=config,
+            checkpoint_dir=checkpoint_dir,
+            fabric=fabric,
+            generate_strategy=None,
+            kv_cache_initialized=False,
+            fixed_kv_cache_size=False,
+        )
+
+    def distribute(
+        self,
+        accelerator: Literal["cpu", "cuda", "auto"] = "auto",
+        devices: Union[int, Literal["auto"]] = "auto",
+        precision: Optional[Any] = None,
+        quantize: Optional[Literal["bnb.nf4", "bnb.nf4-dq", "bnb.fp4", "bnb.fp4-dq", "bnb.int8"]] = None,
+        generate_strategy: Optional[Literal["sequential", "tensor_parallel"]] = None,
+        fixed_kv_cache_size: Union[int, Literal["max_model_supported"], None] = None,
+    ) -> None:
+        """
+        Moves the model onto specified devices for single-GPU or multi-GPU inference
+
+        accelerator: Which device type to load the model on ("cpu", "gpu", "mps", "cuda", or "auto")
+        devices: The number of devices (1, 2, etc.) or "auto", which uses all available devices
+        quantize: Whether to quantize the model and using which method:
+            - bnb.nf4, bnb.nf4-dq, bnb.fp4, bnb.fp4-dq: 4-bit quantization from bitsandbytes
+            - bnb.int8: 8-bit quantization from bitsandbytes
+            for more details, see https://github.com/Lightning-AI/litgpt/blob/main/tutorials/quantize.md
+        precision: Indicates the Fabric precision setting to use.
+            For instance, "32-true", "16-mixed", "16-true", "bf16-mixed", "bf16-true".
+            For more details, see https://lightning.ai/docs/fabric/stable/api/fabric_args.html#precision
+        generate_strategy: Whether to use a sequential model generation strategy. The "sequential" settings allows running
+            models that wouldn't fit in a single card by partitioning the transformer blocks across
+            all devices and running them sequentially. Sequential generation may be slower but allows using larger models.
+            Note that sequential generation sets `fixed_kv_cache_size="max_model_supported"`. You can set it to a lower integer
+            value, `fixed_kv_cache_size=256` to reduce memory. The `fixed_kv_cache_size` value determines the maximum number
+            of tokens that can be returned via `llm.generate(...)`.
+        fixed_kv_cache_size: If set to an integer value or "max_model_supported" is set, the kv-cache won't be resized dynamically
+            during `llm.generate` calls. Use this setting if you plan to compile the model or use `generate_strategy="sequential`.
+            Note that the chosen `fixed_kv_cache_size` value determines the maximum number of tokens that can be returned in `llm.generate(...)`.
+        """
+
+        if self.checkpoint_dir is None:
+            raise NotImplementedError(
+                "The LLM was initialized with init='random' but .distribute() "
+                "currently only supports pretrained weights."
+            )
+
+        allowed_accelerators = {"cpu", "gpu", "cuda", "mps", "auto"}
+        if accelerator not in allowed_accelerators:
+            raise ValueError(f"Invalid accelerator: {accelerator}. Must be one of {allowed_accelerators}.")
+
+        if accelerator == "auto":
+            if torch.cuda.is_available():
+                accelerator = "cuda"
+            elif torch.backends.mps.is_available():
+                accelerator = "mps"
+            else:
+                accelerator = "cpu"
+
+        if generate_strategy in ("sequential", "tensor_parallel") and accelerator not in ("cuda", "gpu"):
+            raise NotImplementedError(
+                f"generate_strategy='{generate_strategy}' is only supported for accelerator='cuda'|'gpu'."
+            )
+
+        if devices == "auto":
+            if generate_strategy in ("sequential", "tensor_parallel"):
+                total_devices = CUDAAccelerator.auto_device_count()
+            else:
+                total_devices = 1
+        elif isinstance(devices, int) and accelerator == "cuda":
+            use_devices = calculate_number_of_devices(devices)
+            total_devices = CUDAAccelerator.auto_device_count()
+            if use_devices > total_devices:
+                raise ValueError(
+                    f"You selected more devices ({use_devices}) than available in your system ({total_devices})."
+                )
+            else:
+                total_devices = use_devices
+
+            if total_devices > 1 and generate_strategy not in ("sequential", "tensor_parallel"):
+                raise NotImplementedError(
+                    "Support for multiple devices is currently only implemented for generate_strategy='sequential'|'tensor_parallel'."
+                )
+        elif accelerator == "cpu" or accelerator == "mps":
+            total_devices = 1
+
+        else:
+            raise ValueError(f"devices argument must be an integer or 'auto', got {devices}")
+
+        print(f"Using {total_devices} device(s)", file=sys.stderr)
+
+        if precision is None:
+            precision = get_default_supported_precision(training=False)
+
+        print("Precision set", file=sys.stderr)
+
+        plugins = None
+        if quantize is not None and quantize.startswith("bnb."):
+            if "mixed" in precision:
+                raise ValueError("The combination of quantization and mixed precision is not supported.")
+            dtype = {"16-true": torch.float16, "bf16-true": torch.bfloat16, "32-true": torch.float32}[precision]
+            plugins = BitsandbytesPrecision(quantize[4:], dtype)
+            precision = None
+
+        # set "ddp" as the strategy for the launching functionality, but there's no data-parallelism
+        if generate_strategy != "tensor_parallel":
+            fabric = L.Fabric(
+                accelerator=accelerator,
+                devices=1,  # Otherwise sequential wouldn't work, see litgpt/generate/sequentially.py
+                # devices=devices,
+                precision=precision,
+                plugins=plugins,
+            )
+        else:
+            fabric = L.Fabric(
+                accelerator=accelerator, devices=total_devices, strategy="ddp", precision=precision, plugins=plugins
+            )
+            if torch.cuda.is_available() and fabric.accelerator.auto_device_count() > 1:
+                check_nvlink_connectivity(fabric)
+                fabric.launch()
+
+        print("Fabric launched", file=sys.stderr)
+
+        self.kv_cache_initialized = False
+        if generate_strategy is None:
+            with fabric.init_module(empty_init=(total_devices > 1)):
+                model = GPT(self.config)
+            model.eval()
+
+            if self.checkpoint_dir is not None:
+                load_checkpoint(fabric, model, self.checkpoint_dir / "lit_model.pth")
+
+            model = fabric.setup_module(model)
+
+            if fixed_kv_cache_size is not None:
+                if fixed_kv_cache_size is None or fixed_kv_cache_size == "max_model_supported":
+                    kv_cache_size = model.max_seq_length
+                else:
+                    kv_cache_size = fixed_kv_cache_size
+                model.set_kv_cache(batch_size=1, max_seq_length=kv_cache_size, device=fabric.device)
+                self.kv_cache_initialized = True
+                self.fixed_kv_cache_size = fixed_kv_cache_size
+
+        elif generate_strategy in ("sequential", "tensor_parallel"):
+            with fabric.init_tensor(), torch.device("meta"):
+                model = GPT(self.config)
+            model.eval()
+
+            if generate_strategy == "sequential":
+                state_dict = torch.load(
+                    str(self.checkpoint_dir / "lit_model.pth"), mmap=True, map_location="cpu", weights_only=False
+                )
+                model.load_state_dict(state_dict, assign=True)
+                model = fabric.setup_module(model, move_to_device=False)
+
+                if fixed_kv_cache_size is None:
+                    fixed_kv_cache_size = "max_model_supported"
+                if fixed_kv_cache_size == "max_model_supported":
+                    kv_cache_size = model.max_seq_length
+                else:
+                    kv_cache_size = fixed_kv_cache_size
+
+                model = sequential(model, fabric.device, kv_cache_size, total_devices)
+                self.fixed_kv_cache_size = fixed_kv_cache_size
+
+            elif generate_strategy == "tensor_parallel":
+                if fabric.global_rank == 0:
+                    pbar = tqdm(total=fabric.world_size, desc="Loading model weights")
+                for rank in range(fabric.world_size):
+                    if fabric.global_rank == rank:
+                        state_dict = torch.load(
+                            str(self.checkpoint_dir / "lit_model.pth"),
+                            mmap=True,
+                            map_location="cpu",
+                            weights_only=False,
+                        )
+                        model.load_state_dict(state_dict, assign=True)
+
+                        # cannot use `.setup_module` because it will wrap with DDP
+                        model = fabric._precision.convert_module(model)
+                        model = tensor_parallel(fabric, model)
+
+                        with fabric.init_tensor():
+                            if fixed_kv_cache_size is None:
+                                fixed_kv_cache_size = "max_model_supported"
+                            if fixed_kv_cache_size == "max_model_supported":
+                                kv_cache_size = model.max_seq_length
+                            else:
+                                kv_cache_size = fixed_kv_cache_size
+                            model.max_seq_length = kv_cache_size
+                            # the rope cache which is on meta device
+                            model.cos, model.sin = model.rope_cache()
+                            # enable the kv cache
+                            model.set_kv_cache(batch_size=1)
+                        model.eval()
+                        model = fabric.to_device(model)
+
+                    fabric.barrier()
+                    if fabric.global_rank == 0:
+                        pbar.update(1)
+
+                if fabric.global_rank == 0:
+                    pbar.close()
+
+            self.kv_cache_initialized = True
+
+        else:
+            raise ValueError(f"Unsupported generate_strategy: {generate_strategy}")
+
+        self.model = model
+        self.fabric = fabric
+        self.preprocessor.device = fabric.device
+
+    @torch.inference_mode()
+    def generate(
+        self,
+        prompt: str,
+        sys_prompt: Optional[str] = None,
+        max_new_tokens: int = 50,
+        temperature: float = 1.0,
+        top_k: Optional[int] = None,
+        top_p: float = 1.0,
+        return_as_token_ids: bool = False,
+        stream: bool = False,
+    ) -> Union[str, torch.Tensor]:
+        """
+        Takes a conditioning sequence (prompt) as input and continues to generate as many tokens as requested.
+
+        Arguments:
+            model: The model to use.
+            prompt: The prompt string to use for generating the samples.
+            sys_prompt: The system prompt string to use for generating the samples.
+                The system prompt allows the user to provide additional instructions to shape all responses by providing additional context, behavioral guidelines, style, and constraints.
+            max_new_tokens: The maximum number of new tokens to return.
+            temperature: Scales the predicted logits by 1 / temperature.
+            top_k: If specified, only sample among the tokens with the k highest probabilities.
+            top_p: If specified, it represents the cumulative probability threshold to consider in the sampling process.
+                In top-p sampling, the next token is sampled from the highest probability tokens
+                whose cumulative probability exceeds the threshold `top_p`. When specified,
+                it must be `0 <= top_p <= 1`. Here, `top_p=0` is equivalent
+                to sampling the most probable token, while `top_p=1` samples from the whole distribution.
+                It can be used in conjunction with `top_k` and `temperature` with the following order
+                of application:
+
+                1. `top_k` sampling
+                2. `temperature` scaling
+                3. `top_p` sampling
+
+                For more details, see https://arxiv.org/abs/1904.09751
+                or https://huyenchip.com/2024/01/16/sampling.html#top_p
+            return_as_token_ids: If True, returns the token IDs as a torch.Tensor. Otherwise, returns the decoded text as a string.
+            stream: If True, returns a generator that yields tokens as they are generated.
+                At the moment, this setting is slower and may use more memory than the non-streaming version.
+                We plan to resolve this in the future.
+        """
+        if self.model is None:
+            raise AttributeError(
+                "The model is not initialized yet; use the .distribute() "
+                "or .trainer_setup() method to initialize the model."
+            )
+        input_ids = self._text_to_token_ids(prompt, sys_prompt)
+        prompt_length = input_ids.size(0)
+        max_returned_tokens = prompt_length + max_new_tokens
+
+        if not self.kv_cache_initialized:
+            if self.fabric is not None:
+                device = self.fabric.device
+            else:
+                device = self.preprocessor.device
+            self.model.set_kv_cache(batch_size=1, max_seq_length=max_returned_tokens, device=device)
+            self.kv_cache_initialized = True
+
+        # Dynamically grow the kv cache size if necessary
+        if not self.fixed_kv_cache_size and self.prev_generated_seq_length < max_returned_tokens:
+            tmp_device = self.model.mask_cache.device
+            self.model.clear_kv_cache()
+            self.model.set_kv_cache(batch_size=1, max_seq_length=max_returned_tokens, device=tmp_device)
+
+        else:
+            for block in self.model.transformer.h:
+                block.attn.kv_cache.reset_parameters()
+
+        self.prev_generated_seq_length = max_returned_tokens
+        self.model.eval()
+
+        def iterator():
+            outputs = stream_generate_fn(
+                model=self.model,
+                prompt=input_ids,
+                max_returned_tokens=max_returned_tokens,
+                temperature=temperature,
+                top_k=top_k,
+                top_p=top_p,
+                stop_tokens=([self.preprocessor.tokenizer.eos_id],),
+            )
+            if return_as_token_ids:
+                yield from outputs
+            else:
+                for output in outputs:
+                    yield self.preprocessor.decode(output)
+            return
+
+        if stream:
+            outputs = iterator()
+        else:
+            outputs = generate_fn(
+                model=self.model,
+                prompt=input_ids,
+                max_returned_tokens=max_returned_tokens,
+                temperature=temperature,
+                top_k=top_k,
+                top_p=top_p,
+                eos_id=self.preprocessor.tokenizer.eos_id,
+                include_prompt=False,
+            )
+
+        if stream:
+            return outputs
+        elif return_as_token_ids:
+            return outputs
+        else:
+            return self.preprocessor.decode(outputs)
+
+    def _text_to_token_ids(self, prompt: str, sys_prompt: Optional[str] = None) -> torch.Tensor:
+        """Utility method to convert a prompt text to token IDs"""
+        prompt = self.prompt_style.apply(prompt, sys_prompt=sys_prompt)
+        input_ids = self.preprocessor.encode(prompt)
+        return input_ids
+
+    def benchmark(self, num_iterations=1, **kwargs):
+        """
+        A wrapper around the .generate() method to calculate runtime performance.
+
+        Arguments:
+        num_iterations: How often the `.generate()` call is repeated.
+        kwargs: Keyword arguments that are passed to the .generate() method.
+        """
+        benchmark_dict = {}
+
+        for i in range(num_iterations):
+            time_to_first_token = None
+            t0 = time.perf_counter()
+            outputs = self.generate(**kwargs)
+
+            if kwargs.get("stream", False):
+                gen_outputs = []
+                for e in outputs:
+                    if time_to_first_token is None:
+                        t1 = time.perf_counter()
+                        time_to_first_token = t1 - t0
+                    gen_outputs.append(e)
+                outputs = "".join(gen_outputs)
+            else:
+                outputs = self.generate(
+                    **kwargs,
+                )
+            benchmark_dict.setdefault("Seconds total", []).append(time.perf_counter() - t0)
+
+            benchmark_dict.setdefault("Seconds to first token", []).append(time_to_first_token)
+            tokens_generated = self.preprocessor.encode(outputs).size(0)
+            benchmark_dict.setdefault("Tokens generated", []).append(tokens_generated)
+            benchmark_dict.setdefault("Inference speed in tokens/sec", []).append(
+                benchmark_dict["Tokens generated"][-1] / benchmark_dict["Seconds total"][-1]
+            )
+            if self.fabric is not None and self.fabric.device.type == "cuda":
+                benchmark_dict.setdefault("Total GPU memory allocated in GB", []).append(
+                    torch.cuda.max_memory_allocated() / 1e9
+                )
+
+        return outputs, benchmark_dict
+
+
+class Preprocessor:
+    """
+    Preprocessor class for tokenization and de-tokenization.
+    """
+
+    def __init__(self, tokenizer: Tokenizer, device: str = "cpu") -> None:
+        self.tokenizer = tokenizer
+        self.device = device
+
+    def encode(self, text: str) -> torch.Tensor:
+        return self.tokenizer.encode(text, device=self.device)
+
+    def decode(self, token_ids: torch.Tensor) -> str:
+        return self.tokenizer.decode(token_ids)
+
+
+def calculate_number_of_devices(devices):
+    """
+    Utility function to calculate the number of devices.
+    """
+    num_devices = devices if isinstance(devices, int) else len(devices) if isinstance(devices, list) else 0
+    return num_devices
+
+
+def benchmark_dict_to_markdown_table(data):
+    """
+    Converts .benchmark() outputs to a markdown table
+    """
+    markdown_table = (
+        "| Metric                              | Mean                        | Std Dev                     |\n"
+    )
+    markdown_table += (
+        "|-------------------------------------|-----------------------------|-----------------------------|\n"
+    )
+
+    for key, values in data.items():
+        mean_value = np.mean(values)
+        std_dev_value = np.std(values, ddof=1)
+
+        formatted_mean = f"{mean_value:.2f}"
+        formatted_std_dev = f"{std_dev_value:.2f}"
+
+        markdown_table += f"| {key.ljust(35)} | {formatted_mean.ljust(27)} | {formatted_std_dev.ljust(27)} |\n"
+
+    return markdown_table
+
+
+def pull_request_benchmark_util(model_name="microsoft/phi-2", num_iterations=6):
+    def print_table(header, data):
+        print(f"\n### {header}\n")
+        markdown_table = (
+            f"| Metric                               | First Iteration | "
+            f"Iter 2-{num_iterations} Mean     | Iter 2-{num_iterations} Standard Dev.  |\n"
+            f"|--------------------------------------|-----------------|"
+            f"-------------------|-------------------------|\n"
+        )
+
+        for key, value in data.items():
+            first_iteration = f"{value[0]:.2f}" if value[0] is not None else "N/A"
+            clean_values = [v for v in value[1:] if v is not None]
+
+            if clean_values:
+                mean_value = np.mean(clean_values)
+                std_dev_value = np.std(clean_values, ddof=1)
+                mean_str = f"{mean_value:.2f}"
+                std_dev_str = f"{std_dev_value:.2f}"
+            else:
+                mean_str = "N/A"
+                std_dev_str = "N/A"
+
+            markdown_table += f"| {key:<36} | {first_iteration:<15} | {mean_str:<17} | {std_dev_str:<23} |\n"
+        print(markdown_table)
+
+    import subprocess
+
+    try:
+        g_hash = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"], capture_output=True, text=True, check=True
+        ).stdout.strip()
+        print(f"Git Commit Hash: {g_hash}")
+    except subprocess.CalledProcessError:
+        print("Git Commit Hash: N/A")
+    print(f"PyTorch version: {torch.__version__}")
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Device: {device}\n")
+
+    # 1st table
+    llm = LLM.load(
+        model=model_name,
+    )
+    text, bench_d = llm.benchmark(num_iterations=num_iterations, prompt="What do llamas eat?", top_k=1)
+    print_table(f"Defaults ({model_name}), 1st time", bench_d)
+    del llm
+
+    # 2nd table
+    llm = LLM.load(
+        model=model_name,
+    )
+    text, bench_d = llm.benchmark(num_iterations=num_iterations, prompt="What do llamas eat?", top_k=1)
+    print_table(f"Defaults ({model_name}), 2nd time", bench_d)
+    del llm
+
+    # 3rd table
+    llm = LLM.load(
+        model=model_name,
+    )
+    text, bench_d = llm.benchmark(num_iterations=num_iterations, prompt="What do llamas eat?", top_k=1, stream=True)
+    print_table("stream=True", bench_d)
+    del llm
+
+    # 4th table
+    llm = LLM.load(model=model_name, distribute=None)
+    llm.distribute(fixed_kv_cache_size=500)
+
+    text, bench_d = llm.benchmark(num_iterations=num_iterations, prompt="What do llamas eat?", top_k=1, stream=True)
+    print_table("stream=True + fixed_kv_cache=500", bench_d)

litgpt/args.py

@@ -0,0 +1,104 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import math
+import warnings
+from dataclasses import dataclass
+from typing import Optional, Union
+
+
+@dataclass
+class TrainArgs:
+    """Training-related arguments"""
+
+    save_interval: Optional[int] = 1000
+    """Number of optimizer steps between saving checkpoints"""
+    log_interval: int = 1
+    """Number of iterations between logging calls"""
+    global_batch_size: int = 64
+    """Number of samples between optimizer steps across data-parallel ranks"""
+    micro_batch_size: int = 4
+    """Number of samples per data-parallel rank"""
+    lr_warmup_steps: Optional[int] = 100
+    """Number of iterations with learning rate warmup active"""
+    lr_warmup_fraction: Optional[float] = None
+    """The fraction of an epoch to use for learning rate warmup"""
+    epochs: Optional[int] = None
+    """Number of epochs to train on"""
+    # TODO: `pretrain` is the only script using `max_tokens` explicitly. replace it with epoch_size*epochs?
+    max_tokens: Optional[int] = None
+    """Total number of tokens to train on"""
+    max_steps: Optional[int] = None
+    """Limits the number of optimizer steps to run"""
+    max_seq_length: Optional[int] = None
+    """Limits the length of samples"""
+    tie_embeddings: Optional[bool] = None
+    """Whether to tie the embedding weights with the language modeling head weights"""
+
+    # Optimization args
+    max_norm: Optional[float] = None
+    min_lr: float = 6e-5
+
+    def __post_init__(self) -> None:
+        if self.lr_warmup_fraction and self.lr_warmup_steps:
+            raise ValueError(
+                "Can't provide both `--train.lr_warmup_fraction` and `--train.lr_warmup_steps`. Choose one."
+            )
+        if self.lr_warmup_fraction and not (0 <= self.lr_warmup_fraction <= 1):
+            raise ValueError("`--train.lr_warmup_fraction` must be between 0 and 1.")
+
+        if self.lr_warmup_steps and self.max_steps and (self.lr_warmup_steps >= self.max_steps):
+            warnings.warn(
+                "`--train.lr_warmup_steps` should be less than `--train.max_steps`."
+                f" Got {self.lr_warmup_steps} lr_warmup_steps and {self.max_steps} max_steps.",
+                UserWarning,
+            )
+
+    def gradient_accumulation_iters(self, devices: int, num_nodes: int = 1) -> int:
+        """Number of iterations between gradient synchronizations"""
+        gradient_accumulation_iters = self.batch_size(devices, num_nodes) // self.micro_batch_size
+        assert gradient_accumulation_iters > 0
+        return gradient_accumulation_iters
+
+    def batch_size(self, devices: int, num_nodes: int = 1) -> int:
+        """Number of samples between optimizer steps per data-parallel rank"""
+        batch_size = self.global_batch_size // (devices * num_nodes)
+        assert batch_size > 0
+        return batch_size
+
+    def warmup_iters(self, devices: int, num_nodes: int, max_iters: int, train_dataloader) -> int:
+        """Number of iterations to warm up the learning rate."""
+        if self.lr_warmup_fraction:
+            return min(max_iters, math.ceil(self.lr_warmup_fraction * len(train_dataloader)))
+        if self.lr_warmup_steps:
+            return min(max_iters, self.lr_warmup_steps * self.gradient_accumulation_iters(devices, num_nodes))
+        return 0
+
+
+@dataclass
+class EvalArgs:
+    """Evaluation-related arguments"""
+
+    interval: int = 600
+    """Number of optimizer steps between evaluation calls"""
+    max_new_tokens: Optional[int] = None
+    """Number of tokens to generate"""
+    max_iters: int = 100
+    """Number of iterations"""
+    initial_validation: bool = False
+    """Whether to evaluate on the validation set at the beginning of the training"""
+    final_validation: bool = True
+    """Whether to evaluate on the validation set at the end of the training"""
+    evaluate_example: Union[str, int] = "first"
+    """How to pick an example instruction to evaluate periodically during training.
+       Can be "first", "random", or an integer index to pick a specific example."""
+
+
+@dataclass
+class LogArgs:
+    """Logging-related arguments"""
+
+    project: Optional[str] = None
+    """Project name"""
+    run: Optional[str] = None
+    """Run name"""
+    group: Optional[str] = None
+    """Group name"""

litgpt/config.py

@@ -0,0 +1,3087 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+from copy import deepcopy
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, List, Literal, Optional, Type, Union
+
+import yaml
+from typing_extensions import Self
+
+
+def find_multiple(n: int, k: int) -> int:
+    """Utility function for finding the nearest value to n which is a multiple of k.
+
+    NOTE: We define this function in this module rather than `litgpt.utils` so that users can import
+    this file to do configuration manipulations in Python environments which do not include all the dependencies
+    demanded by `litgpt.utils`.
+    """
+    assert k > 0
+    if n % k == 0:
+        return n
+    return n + k - (n % k)
+
+
+@dataclass
+class Config:
+    name: str = ""
+    hf_config: dict = field(default_factory=dict)
+    # General size parameters
+    block_size: int = 4096
+    n_layer: int = 16
+    n_embd: int = 4096
+    vocab_size: int = 50254
+    padding_multiple: int = 512
+    padded_vocab_size: Optional[int] = None
+    # Transformer block (structure, normalizations)
+    norm_class_name: Literal["LayerNorm", "RMSNorm"] = "LayerNorm"
+    norm_eps: float = 1e-5
+    norm_qk: bool = False
+    norm_qk_type: Literal["default", "olmo2"] = "default"
+    post_attention_norm: bool = False
+    post_mlp_norm: bool = False
+    parallel_residual: bool = True
+    shared_attention_norm: bool = False
+    # Transformer block (self-attention)
+    n_head: int = 32
+    head_size: Optional[int] = None
+    # to use multi-head attention (MHA), set this to `n_head` (default)
+    # to use multi-query attention (MQA), set this to 1
+    # to use grouped-query attention (GQA), set this to a value in between
+    # Example with `n_head=4`
+    # ┌───┐┌───┐┌───┐┌───┐     ┌───┐    ┌───┐             ┌───┐
+    # │ v ││ v ││ v ││ v │     │ v │    │ v │             │ v │
+    # └───┘└───┘└───┘└───┘     └───┘    └───┘             └───┘
+    #   │    │    │    │         │        │                 │
+    # ┌───┐┌───┐┌───┐┌───┐     ┌───┐    ┌───┐             ┌───┐
+    # │ k ││ k ││ k ││ k │     │ k │    │ k │             │ k │
+    # └───┘└───┘└───┘└───┘     └───┘    └───┘             └───┘
+    #   │    │    │    │      ┌──┴──┐  ┌──┴──┐      ┌────┬──┴─┬────┐
+    # ┌───┐┌───┐┌───┐┌───┐  ┌───┐┌───┐┌───┐┌───┐  ┌───┐┌───┐┌───┐┌───┐
+    # │ q ││ q ││ q ││ q │  │ q ││ q ││ q ││ q │  │ q ││ q ││ q ││ q │
+    # └───┘└───┘└───┘└───┘  └───┘└───┘└───┘└───┘  └───┘└───┘└───┘└───┘
+    # ◀──────────────────▶  ◀──────────────────▶  ◀──────────────────▶
+    #         MHA                    GQA                   MQA
+    #   n_query_groups=4       n_query_groups=2      n_query_groups=1
+    #
+    # credit https://arxiv.org/pdf/2305.13245.pdf
+    n_query_groups: Optional[int] = None
+    attn_bias: bool = False
+    attention_scores_scalar: Optional[int] = None
+    sliding_window_size: Optional[int] = None
+    sliding_window_indices: Optional[List] = None
+    # if `attention_logit_softcapping` is used, cannot use optimized
+    # `torch.nn.functional.scaled_dot_product_attention` (which implements
+    # Flash attention), may result in higher memory and runtime footprint.
+    attention_logit_softcapping: Optional[float] = None
+    # Rotary position embedding (RoPE)
+    rope_base: int = 10000
+    rotary_percentage: float = 0.25
+    rope_condense_ratio: int = 1
+    rope_adjustments: Optional[dict] = None
+    # Transformer block (MLP)
+    intermediate_size: Optional[int] = None
+    moe_intermediate_size: Optional[int] = None
+    bias: bool = True
+    mlp_class_name: Literal["GptNeoxMLP", "LLaMAMLP", "GemmaMLP", "LLaMAMoE"] = "GptNeoxMLP"
+    gelu_approximate: str = "none"
+    n_expert: int = 0
+    n_expert_per_token: int = 0
+    # GPT before/after blocks
+    scale_embeddings: bool = False
+    lm_head_bias: bool = False
+    final_logit_softcapping: Optional[float] = None
+    norm_1: bool = True
+    norm_2: bool = True
+    # The base period of the RoPE embeddings for local attention.
+    # If not provided, rope_theta will be used for both local and global attention.
+    rope_local_base_freq: Optional[float] = None
+    rope_indices: Optional[List] = None
+
+    def __post_init__(self):
+        if not self.name:
+            self.name = self.hf_config.get("name", self.name)
+
+        if self.head_size is None:
+            assert self.n_embd % self.n_head == 0
+            self.head_size = self.n_embd // self.n_head
+
+        # vocab size should be a power of 2 to be optimal on hardware. compute the closest value
+        if self.padded_vocab_size is None:
+            self.padded_vocab_size = find_multiple(self.vocab_size, self.padding_multiple)
+        else:
+            # vocab size shouldn't be larger than padded vocab size
+            self.vocab_size = min(self.vocab_size, self.padded_vocab_size)
+
+        # compute the number of query groups
+        if self.n_query_groups is not None:
+            assert self.n_head % self.n_query_groups == 0
+        else:
+            self.n_query_groups = self.n_head
+
+        # compute the intermediate size for MLP if not set
+        if self.intermediate_size is None:
+            if self.mlp_class_name == "LLaMAMLP":
+                raise ValueError(f"The config {self.name!r}, needs to set the `intermediate_size`")
+            self.intermediate_size = 4 * self.n_embd
+
+        self.rope_n_elem = int(self.rotary_percentage * self.head_size)
+
+        if self.sliding_window_size is not None and self.sliding_window_indices is None:
+            self.sliding_window_indices = [1] * self.n_layer
+
+        if self.rope_local_base_freq is not None and self.rope_indices is None:
+            self.rope_indices = [1] * self.n_layer
+
+    @classmethod
+    def from_name(cls, name: str, **kwargs: Any) -> Optional[Self]:
+        if name not in name_to_config:
+            # search through all `config['hf_config']['name']`
+            try:
+                conf_dict = next(
+                    config
+                    for config in configs
+                    if name == config["hf_config"]["name"]
+                    or config["hf_config"]["org"] + "/" + config["hf_config"]["name"] == name
+                )
+            except StopIteration:
+                raise ValueError(f"{name!r} is not a supported config name")
+        else:
+            conf_dict = name_to_config[name]
+
+        conf_dict = conf_dict.copy()
+        conf_dict.update(kwargs)
+        return cls(**conf_dict)
+
+    @classmethod
+    def from_file(cls, path: Union[str, Path], **kwargs: Any) -> Self:
+        with open(path, encoding="utf-8") as fp:
+            file_kwargs = yaml.safe_load(fp)
+            if file_kwargs is None:
+                raise ValueError(f"{path} is empty which is likely unexpected.")
+        file_kwargs.update(kwargs)
+        return cls(**file_kwargs)
+
+    @classmethod
+    def from_checkpoint(cls, path: Path, **kwargs: Any) -> Self:
+        """Automatically load `model_config.yaml` and if it doesn't exist - a matching config from `litgpt/config.py`."""
+        if (config_path := path / "model_config.yaml").is_file():
+            return cls.from_file(config_path, **kwargs)
+        if (model_name := path.name) in name_to_config:
+            return cls.from_name(model_name, **kwargs)
+        raise FileNotFoundError(f"For {str(path)!r} neither 'model_config.yaml' nor matching config exists.")
+
+    @property
+    def mlp_class(self) -> Type:
+        # `self.mlp_class_name` cannot be the type to keep the config serializable
+        import litgpt.model
+
+        return getattr(litgpt.model, self.mlp_class_name)
+
+    @property
+    def norm_class(self) -> Type:
+        # `self.norm_class_name` cannot be the type to keep the config serializable
+
+        from functools import partial
+
+        import torch  # Torch import is lazy to make config loading faster
+
+        if self.norm_class_name == "RMSNorm":
+            from litgpt.model import RMSNorm
+
+            return partial(RMSNorm, add_unit_offset="Gemma" in self.name)
+
+        if self.norm_class_name == "LayerNorm" and "OLMo" in self.name:
+            # this makes it equivalent to `torch.nn.functional.layer_norm`
+            # that is used by OLMo
+            # Table 5 caption in the OLMo paper shows this - https://aclanthology.org/2024.acl-long.841
+            return partial(torch.nn.LayerNorm, elementwise_affine=False)
+
+        return getattr(torch.nn, self.norm_class_name)
+
+
+########################
+# Stability AI StableLM
+########################
+configs = [
+    # https://huggingface.co/stabilityai/stablelm-base-alpha-3b/blob/main/config.json
+    dict(name="stablelm-base-alpha-3b", hf_config=dict(org="stabilityai", name="stablelm-base-alpha-3b")),
+    # https://huggingface.co/stabilityai/stablelm-base-alpha-7b/blob/main/config.json
+    dict(
+        name="stablelm-base-alpha-7b",
+        hf_config=dict(org="stabilityai", name="stablelm-base-alpha-7b"),
+        n_head=48,
+        n_embd=6144,
+        padding_multiple=256,
+    ),
+    # https://huggingface.co/stabilityai/stablelm-tuned-alpha-3b/blob/main/config.json
+    dict(name="stablelm-tuned-alpha-3b", hf_config=dict(org="stabilityai", name="stablelm-tuned-alpha-3b"), n_head=32),
+    # https://huggingface.co/stabilityai/stablelm-tuned-alpha-7b/blob/main/config.json
+    dict(
+        name="stablelm-tuned-alpha-7b",
+        hf_config=dict(org="stabilityai", name="stablelm-tuned-alpha-7b"),
+        n_head=48,
+        n_embd=6144,
+        padding_multiple=256,
+    ),
+    # https://huggingface.co/stabilityai/stablelm-3b-4e1t/blob/main/config.json
+    dict(
+        name="stablelm-3b-4e1t",
+        hf_config=dict(org="stabilityai", name="stablelm-3b-4e1t"),
+        padded_vocab_size=50304,
+        n_layer=32,
+        n_head=32,
+        n_embd=2560,
+        parallel_residual=False,
+        bias=False,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=6912,
+    ),
+    # https://huggingface.co/stabilityai/stablelm-zephyr-3b/blob/main/config.json
+    dict(
+        name="stablelm-zephyr-3b",
+        hf_config=dict(org="stabilityai", name="stablelm-zephyr-3b"),
+        padded_vocab_size=50304,
+        n_layer=32,
+        n_head=32,
+        n_embd=2560,
+        parallel_residual=False,
+        bias=False,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=6912,
+    ),
+]
+
+
+##########################
+# Stability AI StableCode
+##########################
+stablecode = [
+    # https://huggingface.co/stabilityai/stablecode-completion-alpha-3b/blob/main/config.json
+    dict(
+        name="stablecode-completion-alpha-3b",
+        hf_config=dict(org="stabilityai", name="stablecode-completion-alpha-3b"),
+        block_size=16384,
+        vocab_size=49152,
+        n_layer=32,
+        n_embd=2560,
+    ),
+    # https://huggingface.co/stabilityai/stablecode-completion-alpha-3b-4k/blob/main/config.json
+    dict(
+        name="stablecode-completion-alpha-3b-4k",
+        hf_config=dict(org="stabilityai", name="stablecode-completion-alpha-3b-4k"),
+        vocab_size=49152,
+        n_layer=32,
+        n_embd=2560,
+    ),
+    # https://huggingface.co/stabilityai/stablecode-instruct-alpha-3b/blob/main/config.json
+    dict(
+        name="stablecode-instruct-alpha-3b",
+        hf_config=dict(org="stabilityai", name="stablecode-instruct-alpha-3b"),
+        vocab_size=49152,
+        n_layer=32,
+        n_embd=2560,
+    ),
+    # https://huggingface.co/stabilityai/stable-code-3b/blob/main/config.json
+    dict(
+        name="stable-code-3b",
+        hf_config=dict(org="stabilityai", name="stable-code-3b"),
+        padded_vocab_size=50304,
+        n_layer=32,
+        n_embd=2560,
+        block_size=16384,
+        parallel_residual=False,
+        bias=False,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=6912,
+    ),
+]
+configs.extend(stablecode)
+
+
+####################
+# EleutherAI Pythia
+####################
+pythia = [
+    # https://huggingface.co/EleutherAI/pythia-14m/blob/main/config.json
+    dict(
+        name="pythia-14m",
+        hf_config=dict(org="EleutherAI", name="pythia-14m"),
+        block_size=512,
+        n_layer=6,
+        n_embd=128,
+        n_head=4,
+        padding_multiple=128,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-31m/blob/main/config.json
+    dict(
+        name="pythia-31m",
+        hf_config=dict(org="EleutherAI", name="pythia-31m"),
+        block_size=1024,
+        n_layer=6,
+        n_embd=256,
+        n_head=8,
+        padding_multiple=128,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-70m/blob/main/config.json
+    dict(
+        name="pythia-70m",
+        hf_config=dict(org="EleutherAI", name="pythia-70m"),
+        block_size=2048,
+        n_layer=6,
+        n_embd=512,
+        n_head=8,
+        padding_multiple=128,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-160m/blob/main/config.json
+    dict(
+        name="pythia-160m",
+        hf_config=dict(org="EleutherAI", name="pythia-160m"),
+        block_size=2048,
+        n_layer=12,
+        n_embd=768,
+        n_head=12,
+        padding_multiple=128,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-410m/blob/main/config.json
+    dict(
+        name="pythia-410m",
+        hf_config=dict(org="EleutherAI", name="pythia-410m"),
+        block_size=2048,
+        n_layer=24,
+        n_embd=1024,
+        n_head=16,
+        padding_multiple=128,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-1b/blob/main/config.json
+    dict(
+        name="pythia-1b",
+        hf_config=dict(org="EleutherAI", name="pythia-1b"),
+        block_size=2048,
+        n_embd=2048,
+        n_head=8,
+        padding_multiple=128,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-1.4b/blob/main/config.json
+    dict(
+        name="pythia-1.4b",
+        hf_config=dict(org="EleutherAI", name="pythia-1.4b"),
+        block_size=2048,
+        n_layer=24,
+        n_embd=2048,
+        n_head=16,
+        padding_multiple=128,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-2.8b/blob/main/config.json
+    dict(
+        name="pythia-2.8b",
+        hf_config=dict(org="EleutherAI", name="pythia-2.8b"),
+        block_size=2048,
+        n_layer=32,
+        n_embd=2560,
+        padding_multiple=128,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-6.9b/blob/main/config.json
+    dict(
+        name="pythia-6.9b",
+        hf_config=dict(org="EleutherAI", name="pythia-6.9b"),
+        block_size=2048,
+        n_layer=32,
+        padding_multiple=256,
+    ),
+    # https://huggingface.co/EleutherAI/pythia-12b/blob/main/config.json
+    dict(
+        name="pythia-12b",
+        hf_config=dict(org="EleutherAI", name="pythia-12b"),
+        block_size=2048,
+        n_layer=36,
+        n_embd=5120,
+        n_head=40,
+    ),
+]
+configs.extend(pythia)
+for c in pythia:
+    # "pythia-14m" and "pythia-31m" don't have deduped version
+    if c["name"] in ("pythia-14m", "pythia-31m"):
+        continue
+    copy = deepcopy(c)
+    copy["name"] = f"{c['name']}-deduped"
+    copy["hf_config"]["name"] = f"{c['hf_config']['name']}-deduped"
+    configs.append(copy)
+
+
+#################
+# TII UAE Falcon
+#################
+falcon = [
+    # https://huggingface.co/tiiuae/falcon-7b/blob/main/config.json
+    dict(
+        name="falcon-7b{}",
+        hf_config=dict(org="tiiuae", name="falcon-7b{}"),
+        block_size=2048,
+        vocab_size=65024,
+        padded_vocab_size=65024,
+        n_layer=32,
+        n_head=71,
+        n_embd=4544,
+        rotary_percentage=1.0,
+        n_query_groups=1,
+        bias=False,
+        # this is not in the config, but in the original model implementation, only for this config
+        shared_attention_norm=True,
+    ),
+    # https://huggingface.co/tiiuae/falcon-40b/blob/main/config.json
+    dict(
+        name="falcon-40b{}",
+        hf_config=dict(org="tiiuae", name="falcon-40b{}"),
+        block_size=2048,
+        vocab_size=65024,
+        padded_vocab_size=65024,
+        n_layer=60,
+        n_head=128,
+        n_embd=8192,
+        rotary_percentage=1.0,
+        n_query_groups=8,
+        bias=False,
+    ),
+]
+for c in falcon:
+    for kind in ("", "-instruct"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+
+# https://huggingface.co/tiiuae/falcon-180b/blob/main/config.json
+falcon180b = dict(
+    name="falcon-180B{}",
+    hf_config=dict(org="tiiuae", name="falcon-180B{}"),
+    block_size=2048,
+    vocab_size=65024,
+    padded_vocab_size=65024,
+    n_layer=80,
+    n_head=232,
+    n_embd=14848,
+    rotary_percentage=1.0,
+    n_query_groups=8,
+    bias=False,
+)
+
+for kind in ("", "-chat"):
+    copy = deepcopy(falcon180b)
+    copy["name"] = falcon180b["name"].format(kind)
+    copy["hf_config"]["name"] = falcon180b["hf_config"]["name"].format(kind)
+    configs.append(copy)
+
+falcon3 = [
+    # https://huggingface.co/tiiuae/Falcon3-1B-Base/blob/main/config.json
+    dict(
+        name="Falcon3-1B{}",
+        hf_config=dict(org="tiiuae", name="Falcon3-1B{}"),
+        block_size=4096,
+        vocab_size=131072,
+        padded_vocab_size=131072,
+        n_layer=18,
+        n_head=8,
+        n_query_groups=4,
+        n_embd=2048,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        rope_base=1000042,
+        norm_eps=1e-6,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8192,
+    ),
+    # https://huggingface.co/tiiuae/Falcon3-3B-Base/blob/main/config.json
+    dict(
+        name="Falcon3-3B{}",
+        hf_config=dict(org="tiiuae", name="Falcon3-3B{}"),
+        block_size=32768,
+        vocab_size=131072,
+        padded_vocab_size=131072,
+        n_layer=22,
+        n_head=12,
+        n_query_groups=4,
+        n_embd=3072,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        rope_base=1000042,
+        norm_eps=1e-6,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=9216,
+    ),
+    # https://huggingface.co/tiiuae/Falcon3-7B-Base/blob/main/config.json
+    dict(
+        name="Falcon3-7B{}",
+        hf_config=dict(org="tiiuae", name="Falcon3-7B{}"),
+        block_size=32768,
+        vocab_size=131072,
+        padded_vocab_size=131072,
+        n_layer=28,
+        n_head=12,
+        n_query_groups=4,
+        n_embd=3072,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        rope_base=1000042,
+        norm_eps=1e-6,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=23040,
+    ),
+    # https://huggingface.co/tiiuae/Falcon3-10B-Base/blob/main/config.json
+    dict(
+        name="Falcon3-10B{}",
+        hf_config=dict(org="tiiuae", name="Falcon3-10B{}"),
+        block_size=32768,
+        vocab_size=131072,
+        padded_vocab_size=131072,
+        n_layer=40,
+        n_head=12,
+        n_query_groups=4,
+        n_embd=3072,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        rope_base=1000042,
+        norm_eps=1e-6,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=23040,
+    ),
+]
+for c in falcon3:
+    for kind in ("-Base", "-Instruct"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+
+
+#############################
+# OpenLM Research Open LLaMA
+#############################
+open_LLaMA = [
+    # https://huggingface.co/openlm-research/open_llama_3b/blob/main/config.json
+    dict(
+        name="open_llama_3b",
+        hf_config=dict(org="openlm-research", name="open_llama_3b"),
+        block_size=2048,
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=26,
+        n_embd=3200,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-6,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8640,
+    ),
+    # https://huggingface.co/openlm-research/open_llama_7b/blob/main/config.json
+    dict(
+        name="open_llama_7b",
+        hf_config=dict(org="openlm-research", name="open_llama_7b"),
+        block_size=2048,
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-6,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+    ),
+    # https://huggingface.co/openlm-research/open_llama_13b/blob/main/config.json
+    dict(
+        name="open_llama_13b",
+        hf_config=dict(org="openlm-research", name="open_llama_13b"),
+        block_size=2048,
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-6,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+    ),
+]
+configs.extend(open_LLaMA)
+
+###############
+# Meta LLaMA 2
+###############
+llama_2 = [
+    # https://huggingface.co/meta-llama/Llama-2-7b-hf/blob/main/config.json
+    dict(
+        name="Llama-2-7b{}-hf",
+        hf_config=dict(org="meta-llama", name="Llama-2-7b{}-hf"),
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+    ),
+    # https://huggingface.co/meta-llama/Llama-2-13b-hf/blob/main/config.json
+    dict(
+        name="Llama-2-13b{}-hf",
+        hf_config=dict(org="meta-llama", name="Llama-2-13b{}-hf"),
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+    ),
+    # https://huggingface.co/meta-llama/Llama-2-70b-hf/blob/main/config.json
+    dict(
+        name="Llama-2-70b{}-hf",
+        hf_config=dict(org="meta-llama", name="Llama-2-70b{}-hf"),
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+    ),
+]
+for c in llama_2:
+    for kind in ("", "-chat"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+
+
+###############
+# Meta LLaMA 3
+###############
+llama_3 = [
+    # https://huggingface.co/meta-llama/Meta-Llama-3-8B/blob/main/config.json
+    dict(
+        name="Llama-3-8B{}",
+        hf_config=dict(org="meta-llama", name="Meta-Llama-3-8B{}"),
+        block_size=8192,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=32,
+        n_head=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+        rope_base=500000,
+    ),
+    # https://huggingface.co/meta-llama/Meta-Llama-3.1-8B/blob/main/config.json
+    dict(
+        name="Llama-3.1-8B{}",
+        hf_config=dict(org="meta-llama", name="Meta-Llama-3.1-8B{}"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=32,
+        n_head=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+        rope_base=500000,
+        rope_adjustments=dict(factor=8.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+    # https://huggingface.co/meta-llama/Meta-Llama-3-70B/blob/main/config.json
+    dict(
+        name="Llama-3-70B{}",
+        hf_config=dict(org="meta-llama", name="Meta-Llama-3-70B{}"),
+        block_size=8192,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+        rope_base=500000,
+    ),
+    # https://huggingface.co/meta-llama/Meta-Llama-3.1-70B/blob/main/config.json
+    dict(
+        name="Llama-3.1-70B{}",
+        hf_config=dict(org="meta-llama", name="Meta-Llama-3.1-70B{}"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+        rope_base=500000,
+        rope_adjustments=dict(factor=8.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+    # https://huggingface.co/meta-llama/Meta-Llama-3.1-405B/blob/main/config.json
+    dict(
+        name="Llama-3.1-405B{}",
+        hf_config=dict(org="meta-llama", name="Meta-Llama-3.1-405B{}"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=126,
+        n_head=128,
+        n_embd=16384,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=53248,
+        rope_base=500000,
+        rope_adjustments=dict(factor=8.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+    # https://huggingface.co/meta-llama/Llama-3.2-1B/blob/main/config.json
+    dict(
+        name="Llama-3.2-1B{}",
+        hf_config=dict(org="meta-llama", name="Llama-3.2-1B{}"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=16,
+        n_embd=2048,
+        n_head=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8192,
+        rope_base=500000,
+        rope_adjustments=dict(factor=32.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+    # https://huggingface.co/meta-llama/Llama-3.2-3B/blob/main/config.json
+    dict(
+        name="Llama-3.2-3B{}",
+        hf_config=dict(org="meta-llama", name="Llama-3.2-3B{}"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=28,
+        n_embd=3072,
+        n_head=24,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8192,
+        rope_base=500000,
+        rope_adjustments=dict(factor=32.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+    # https://huggingface.co/meta-llama/Llama-3.3-70B-Instruct/blob/main/config.json
+    dict(
+        name="Llama-3.3-70B-Instruct",
+        hf_config=dict(org="meta-llama", name="Llama-3.3-70B-Instruct"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+        rope_base=500000,
+        rope_adjustments=dict(factor=8.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+]
+for c in llama_3:
+    if c["name"] == "Llama-3.3-70B-Instruct":
+        configs.append(c)
+        continue
+    for kind in ("", "-Instruct"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+
+#########################
+# NVIDIA Llama Nemotron
+#########################
+configs.append(
+    dict(
+        name="Llama-3.1-Nemotron-70B-Instruct-HF",
+        hf_config=dict(org="nvidia", name="Llama-3.1-Nemotron-70B-Instruct-HF"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+        rope_base=500000,
+        rope_adjustments=dict(factor=8.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+)
+
+#################
+# Allen AI OLMo
+#################
+olmo = [
+    # https://huggingface.co/allenai/OLMo-1B-hf/blob/main/config.json
+    dict(
+        name="OLMo-1B-hf",
+        hf_config=dict(org="allenai", name="OLMo-1B-hf"),
+        vocab_size=50280,
+        padded_vocab_size=50304,
+        block_size=2048,
+        n_embd=2048,
+        n_layer=16,
+        n_head=16,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="LayerNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8192,
+    ),
+    # https://huggingface.co/allenai/OLMo-7B-hf/blob/main/config.json
+    dict(
+        name="OLMo-7B-hf",
+        hf_config=dict(org="allenai", name="OLMo-7B-hf"),
+        vocab_size=50280,
+        padded_vocab_size=50304,
+        block_size=2048,
+        n_layer=32,
+        n_head=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="LayerNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+    ),
+    # https://huggingface.co/allenai/OLMo-7B-Instruct-hf/blob/main/config.json
+    dict(
+        name="OLMo-7B-Instruct-hf",
+        hf_config=dict(org="allenai", name="OLMo-7B-Instruct-hf"),
+        vocab_size=50280,
+        padded_vocab_size=50304,
+        block_size=2048,
+        n_layer=32,
+        n_head=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="LayerNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+    ),
+]
+
+configs.extend(olmo)
+
+olmo2 = [
+    # https://huggingface.co/allenai/OLMo-2-1124-7B/blob/main/config.json
+    dict(
+        name="OLMo-2-1124-7B{}",
+        hf_config=dict(org="allenai", name="OLMo-2-1124-7B{}"),
+        vocab_size=100278,
+        padded_vocab_size=100352,
+        block_size=4096,
+        n_embd=4096,
+        n_layer=32,
+        n_head=32,
+        n_query_groups=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        norm_eps=1e-06,
+        intermediate_size=11008,
+        rope_base=500000,
+        norm_qk=True,
+        post_mlp_norm=True,
+        norm_1=False,
+        norm_2=False,
+        norm_qk_type="olmo2",
+        post_attention_norm=True,
+    ),
+    # https://huggingface.co/allenai/OLMo-2-1124-13B/blob/main/config.json
+    dict(
+        name="OLMo-2-1124-13B{}",
+        hf_config=dict(org="allenai", name="OLMo-2-1124-13B{}"),
+        vocab_size=100278,
+        padded_vocab_size=100352,
+        block_size=4096,
+        n_embd=5120,
+        n_layer=40,
+        n_head=40,
+        n_query_groups=40,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        norm_eps=1e-06,
+        intermediate_size=13824,
+        rope_base=500000,
+        norm_qk=True,
+        post_mlp_norm=True,
+        norm_1=False,
+        norm_2=False,
+        norm_qk_type="olmo2",
+        post_attention_norm=True,
+    ),
+]
+
+for c in olmo2:
+    for kind in ("", "-SFT", "-DPO", "-Instruct"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+
+###############
+# Google Gemma
+###############
+gemma = [
+    # https://huggingface.co/google/gemma-2b/blob/main/config.json
+    dict(
+        name="Gemma-2b",
+        hf_config=dict(org="google", name="gemma-2b"),
+        scale_embeddings=True,
+        vocab_size=256000,
+        padding_multiple=64,
+        n_embd=2048,
+        n_layer=18,
+        n_head=8,
+        n_query_groups=1,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        intermediate_size=16384,
+    ),
+    # https://huggingface.co/google/gemma-7b/blob/main/config.json
+    dict(
+        name="Gemma-7b",
+        hf_config=dict(org="google", name="gemma-7b"),
+        scale_embeddings=True,
+        vocab_size=256000,
+        padding_multiple=64,
+        n_embd=3072,
+        n_layer=28,
+        n_head=16,
+        head_size=256,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        intermediate_size=24576,
+    ),
+    # https://huggingface.co/google/gemma-2-2b/blob/main/config.json
+    dict(
+        name="Gemma-2-2b",
+        hf_config=dict(org="google", name="gemma-2-2b"),
+        scale_embeddings=True,
+        attention_scores_scalar=256,
+        vocab_size=256000,
+        block_size=8192,
+        sliding_window_size=4096,
+        # only layer with idx 0, 2, 4, ... have sliding window attention
+        sliding_window_indices=[1 if i % 2 == 0 else 0 for i in range(26)],
+        intermediate_size=9216,
+        n_embd=2304,
+        n_layer=26,
+        n_head=8,
+        n_query_groups=4,
+        head_size=256,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        post_attention_norm=True,
+        post_mlp_norm=True,
+        attention_logit_softcapping=50.0,
+        final_logit_softcapping=30.0,
+    ),
+    # https://huggingface.co/google/gemma-2-9b/blob/main/config.json
+    dict(
+        name="Gemma-2-9b",
+        hf_config=dict(org="google", name="gemma-2-9b"),
+        scale_embeddings=True,
+        attention_scores_scalar=256,
+        vocab_size=256000,
+        block_size=8192,
+        sliding_window_size=4096,
+        # only layer with idx 0, 2, 4, ... have sliding window attention
+        sliding_window_indices=[1 if i % 2 == 0 else 0 for i in range(42)],
+        intermediate_size=14336,
+        n_embd=3584,
+        n_layer=42,
+        n_head=16,
+        n_query_groups=8,
+        head_size=256,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        post_attention_norm=True,
+        post_mlp_norm=True,
+        attention_logit_softcapping=50.0,
+        final_logit_softcapping=30.0,
+    ),
+    # https://huggingface.co/google/gemma-2-27b/blob/main/config.json
+    dict(
+        name="Gemma-2-27b",
+        hf_config=dict(org="google", name="gemma-2-27b"),
+        scale_embeddings=True,
+        # In Gemma 2 27B attention scores are scaled not by `sqrt(head_size)` (11.31),
+        # but by `sqrt(n_emb // n_head)` = sqrt(4608 // 32) = 12
+        attention_scores_scalar=144,
+        vocab_size=256000,
+        block_size=8192,
+        sliding_window_size=4096,
+        # only layer with idx 0, 2, 4, ... have sliding window attention
+        sliding_window_indices=[1 if i % 2 == 0 else 0 for i in range(46)],
+        intermediate_size=36864,
+        n_embd=4608,
+        n_layer=46,
+        n_head=32,
+        n_query_groups=16,
+        head_size=128,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        post_attention_norm=True,
+        post_mlp_norm=True,
+        attention_logit_softcapping=50.0,
+        final_logit_softcapping=30.0,
+    ),
+]
+configs.extend(gemma)
+for c in gemma:
+    copy = deepcopy(c)
+    copy["name"] = f"{c['name']}-it"
+    copy["hf_config"]["name"] = f"{c['hf_config']['name']}-it"
+    configs.append(copy)
+
+##################
+# Google Gemma 3
+##################
+gemma3 = [
+    # https://huggingface.co/google/gemma-3-1b-it/blob/main/config.json
+    dict(
+        name="Gemma-3-1b-it",
+        hf_config=dict(org="google", name="gemma-3-1b-it"),
+        scale_embeddings=True,
+        attention_scores_scalar=256,
+        vocab_size=262144,
+        block_size=131072,
+        sliding_window_size=512,
+        # 5 local layers for every global layer
+        sliding_window_indices=[0 if (i + 1) % 6 == 0 else 1 for i in range(26)],
+        intermediate_size=6912,
+        n_embd=1152,
+        n_layer=26,
+        n_head=4,
+        n_query_groups=1,
+        head_size=256,
+        rotary_percentage=1.0,
+        rope_adjustments=None,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        post_attention_norm=True,
+        post_mlp_norm=True,
+        norm_qk=True,
+        rope_base=1000000,
+        rope_local_base_freq=10000,
+        # 5 local layers for every global layer
+        rope_indices=[0 if (i + 1) % 6 == 0 else 1 for i in range(26)],
+    ),
+    # https://huggingface.co/google/gemma-3-4b-it/blob/main/config.json
+    dict(
+        name="Gemma-3-4b-it",
+        hf_config=dict(org="google", name="gemma-3-4b-it"),
+        scale_embeddings=True,
+        attention_scores_scalar=256,
+        vocab_size=262144,
+        block_size=131072,
+        sliding_window_size=1024,
+        # 5 local layers for every global layer
+        sliding_window_indices=[0 if (i + 1) % 6 == 0 else 1 for i in range(34)],
+        intermediate_size=10240,
+        n_embd=2560,
+        n_layer=34,
+        n_head=8,
+        n_query_groups=4,
+        head_size=256,
+        rotary_percentage=1.0,
+        rope_adjustments=dict(factor=8.0),
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        post_attention_norm=True,
+        post_mlp_norm=True,
+        norm_qk=True,
+        rope_base=1000000,
+        rope_local_base_freq=10000,
+        # 5 local layers for every global layer
+        rope_indices=[0 if (i + 1) % 6 == 0 else 1 for i in range(34)],
+    ),
+    # https://huggingface.co/google/gemma-3-12b-it/blob/main/config.json
+    dict(
+        name="Gemma-3-12b-it",
+        hf_config=dict(org="google", name="gemma-3-12b-it"),
+        scale_embeddings=True,
+        attention_scores_scalar=256,
+        vocab_size=262144,
+        block_size=131072,
+        sliding_window_size=1024,
+        # 5 local layers for every global layer
+        sliding_window_indices=[0 if (i + 1) % 6 == 0 else 1 for i in range(48)],
+        intermediate_size=15360,
+        n_embd=3840,
+        n_layer=48,
+        n_head=16,
+        n_query_groups=8,
+        head_size=256,
+        rotary_percentage=1.0,
+        rope_adjustments=dict(factor=8.0),
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        post_attention_norm=True,
+        post_mlp_norm=True,
+        norm_qk=True,
+        rope_base=1000000,
+        rope_local_base_freq=10000,
+        # 5 local layers for every global layer
+        rope_indices=[0 if (i + 1) % 6 == 0 else 1 for i in range(48)],
+    ),
+    # https://huggingface.co/google/gemma-3-27b-it/blob/main/config.json
+    dict(
+        name="Gemma-3-27b-it",
+        hf_config=dict(org="google", name="gemma-3-27b-it"),
+        scale_embeddings=True,
+        attention_scores_scalar=168,
+        vocab_size=262144,
+        block_size=131072,
+        sliding_window_size=1024,
+        # 5 local layers for every global layer
+        sliding_window_indices=[0 if (i + 1) % 6 == 0 else 1 for i in range(62)],
+        intermediate_size=21504,
+        n_embd=5376,
+        n_layer=62,
+        n_head=32,
+        n_query_groups=16,
+        head_size=128,
+        rotary_percentage=1.0,
+        rope_adjustments=dict(factor=8.0),
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        post_attention_norm=True,
+        post_mlp_norm=True,
+        norm_qk=True,
+        rope_base=1000000,
+        rope_local_base_freq=10000,
+        # 5 local layers for every global layer
+        rope_indices=[0 if (i + 1) % 6 == 0 else 1 for i in range(62)],
+    ),
+]
+configs.extend(gemma3)
+
+##################
+# Google CodeGemma
+##################
+codegemma = [
+    # https://huggingface.co/google/codegemma-7b-it/blob/main/config.json
+    dict(
+        name="CodeGemma-7b-it",
+        hf_config=dict(org="google", name="codegemma-7b-it"),
+        scale_embeddings=True,
+        vocab_size=256000,
+        padding_multiple=64,
+        n_embd=3072,
+        n_layer=28,
+        n_head=16,
+        head_size=256,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="GemmaMLP",
+        gelu_approximate="tanh",
+        intermediate_size=24576,
+    ),
+]
+configs.extend(codegemma)
+
+
+##########################
+# Stability AI FreeWilly2
+##########################
+freewilly_2 = [
+    # https://huggingface.co/stabilityai/FreeWilly2/blob/main/config.json
+    dict(
+        name="FreeWilly2",
+        hf_config=dict(org="stabilityai", name="FreeWilly2"),
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+    )
+]
+configs.extend(freewilly_2)
+
+
+##################
+# Meta Code Llama
+##################
+code_llama = [
+    # https://huggingface.co/codellama/CodeLlama-7b-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-7b-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-7b-hf"),
+        block_size=16384,
+        vocab_size=32016,
+        padding_multiple=16,
+        n_layer=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-13b-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-13b-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-13b-hf"),
+        block_size=16384,
+        vocab_size=32016,
+        padding_multiple=16,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-34b-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-34b-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-34b-hf"),
+        block_size=16384,
+        vocab_size=32000,
+        padded_vocab_size=32000,
+        n_layer=48,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=22016,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-70b-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-70b-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-70b-hf"),
+        block_size=16384,
+        vocab_size=32016,
+        padding_multiple=16,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-7b-Python-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-7b-Python-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-7b-Python-hf"),
+        block_size=16384,
+        vocab_size=32000,
+        padded_vocab_size=32000,
+        n_layer=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-13b-Python-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-13b-Python-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-13b-Python-hf"),
+        block_size=16384,
+        vocab_size=32000,
+        padded_vocab_size=32000,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-34b-Python-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-34b-Python-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-34b-Python-hf"),
+        block_size=16384,
+        vocab_size=32000,
+        padded_vocab_size=32000,
+        n_layer=48,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=22016,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-70b-Python-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-70b-Python-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-70b-Python-hf"),
+        block_size=16384,
+        vocab_size=32016,
+        padding_multiple=16,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-7b-Instruct-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-7b-Instruct-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-7b-Instruct-hf"),
+        block_size=16384,
+        vocab_size=32016,
+        padding_multiple=16,
+        n_layer=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-13b-Instruct-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-13b-Instruct-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-13b-Instruct-hf"),
+        block_size=2048,
+        vocab_size=32016,
+        padding_multiple=16,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-34b-Instruct-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-34b-Instruct-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-34b-Instruct-hf"),
+        block_size=16384,
+        vocab_size=32000,
+        padded_vocab_size=32000,
+        n_layer=48,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=22016,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/codellama/CodeLlama-70b-Instruct-hf/blob/main/config.json
+    dict(
+        name="CodeLlama-70b-Instruct-hf",
+        hf_config=dict(org="codellama", name="CodeLlama-70b-Instruct-hf"),
+        block_size=16384,
+        # 32016 is an added token, so not reported in vocab_size
+        # https://huggingface.co/codellama/CodeLlama-70b-Instruct-hf/blob/main/tokenizer_config.json
+        vocab_size=32015,
+        padding_multiple=16,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+        rope_base=1000000,
+    ),
+]
+configs.extend(code_llama)
+
+
+########################
+# garage-bAInd Platypus
+########################
+platypus = [
+    # https://huggingface.co/garage-bAInd/Platypus-30B/blob/main/config.json
+    dict(
+        name="Platypus-30B",
+        hf_config=dict(org="garage-bAInd", name="Platypus-30B"),
+        block_size=2048,
+        padded_vocab_size=32000,
+        n_layer=60,
+        n_head=52,
+        n_embd=6656,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-06,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=17920,
+    ),
+    # https://huggingface.co/garage-bAInd/Platypus2-7B/blob/main/config.json
+    dict(
+        name="Platypus2-7B",
+        hf_config=dict(org="garage-bAInd", name="Platypus2-7B"),
+        padded_vocab_size=32000,
+        n_layer=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+    ),
+    # https://huggingface.co/garage-bAInd/Platypus2-13B/blob/main/config.json
+    dict(
+        name="Platypus2-13B",
+        hf_config=dict(org="garage-bAInd", name="Platypus2-13B"),
+        padded_vocab_size=32000,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+    ),
+    # https://huggingface.co/garage-bAInd/Platypus2-70B/blob/main/config.json
+    dict(
+        name="Platypus2-70B",
+        hf_config=dict(org="garage-bAInd", name="Platypus2-70B"),
+        padded_vocab_size=32000,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+    ),
+    # https://huggingface.co/garage-bAInd/Camel-Platypus2-13B/blob/main/config.json
+    dict(
+        name="Camel-Platypus2-13B",
+        hf_config=dict(org="garage-bAInd", name="Camel-Platypus2-13B"),
+        padded_vocab_size=32000,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+    ),
+    # https://huggingface.co/garage-bAInd/Camel-Platypus2-70B/blob/main/config.json
+    dict(
+        name="Camel-Platypus2-70B",
+        hf_config=dict(org="garage-bAInd", name="Camel-Platypus2-70B"),
+        padded_vocab_size=32000,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+    ),
+    # https://huggingface.co/garage-bAInd/Stable-Platypus2-13B/blob/main/config.json
+    dict(
+        name="Stable-Platypus2-13B",
+        hf_config=dict(org="garage-bAInd", name="Stable-Platypus2-13B"),
+        padded_vocab_size=32000,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+    ),
+    # https://huggingface.co/garage-bAInd/Platypus2-70B-instruct/blob/main/config.json
+    dict(
+        name="Platypus2-70B-instruct",
+        hf_config=dict(org="garage-bAInd", name="Platypus2-70B-instruct"),
+        padded_vocab_size=32000,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+    ),
+]
+configs.extend(platypus)
+
+
+##################################
+# togethercomputer LLaMA-2-7B-32K
+##################################
+together_llama2_32k = [
+    # https://huggingface.co/togethercomputer/LLaMA-2-7B-32K/blob/main/config.json
+    dict(
+        name="LLaMA-2-7B-32K",
+        hf_config=dict(org="togethercomputer", name="LLaMA-2-7B-32K"),
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+        rope_condense_ratio=8,
+    )
+]
+configs.extend(together_llama2_32k)
+
+
+################
+# Microsoft Phi
+################
+phi = [
+    # https://huggingface.co/microsoft/phi-1_5/blob/main/config.json
+    dict(
+        name="phi-1_5",
+        hf_config=dict(org="microsoft", name="phi-1_5"),
+        vocab_size=50257,
+        padded_vocab_size=51200,
+        block_size=2048,
+        n_embd=2048,
+        n_layer=24,
+        rotary_percentage=0.5,  # 32 / (n_embd / n_head) = 32 / 64
+        shared_attention_norm=True,
+        lm_head_bias=True,
+        gelu_approximate="tanh",
+    ),
+    # https://huggingface.co/microsoft/phi-2/blob/main/config.json
+    dict(
+        name="phi-2",
+        hf_config=dict(org="microsoft", name="phi-2"),
+        vocab_size=50257,
+        padded_vocab_size=51200,
+        block_size=2048,
+        n_embd=2560,
+        n_layer=32,
+        rotary_percentage=0.4,  # 32 / (n_embd / n_head) = 32 / 80
+        shared_attention_norm=True,
+        lm_head_bias=True,
+        gelu_approximate="tanh",
+    ),
+    # https://huggingface.co/microsoft/Phi-3-mini-4k-instruct/blob/main/config.json
+    dict(
+        name="Phi-3-mini-4k-instruct",
+        hf_config=dict(org="microsoft", name="Phi-3-mini-4k-instruct"),
+        vocab_size=32000,
+        padded_vocab_size=32064,
+        block_size=4096,
+        n_embd=3072,
+        n_layer=32,
+        rotary_percentage=1.0,
+        bias=False,
+        norm_class_name="RMSNorm",
+        intermediate_size=8192,
+        mlp_class_name="LLaMAMLP",
+        parallel_residual=False,
+        sliding_window_size=2048,
+    ),
+    # https://huggingface.co/microsoft/Phi-3-mini-128k-instruct/blob/main/config.json
+    dict(
+        name="Phi-3-mini-128k-instruct",
+        hf_config=dict(org="microsoft", name="Phi-3-mini-128k-instruct"),
+        vocab_size=32000,
+        padded_vocab_size=32064,
+        block_size=131072,
+        n_embd=3072,
+        n_layer=32,
+        rotary_percentage=1.0,
+        bias=False,
+        norm_class_name="RMSNorm",
+        intermediate_size=8192,
+        mlp_class_name="LLaMAMLP",
+        parallel_residual=False,
+        sliding_window_size=262145,
+    ),
+    # https://huggingface.co/microsoft/Phi-3.5-mini-instruct/blob/main/config.json
+    dict(
+        name="Phi-3.5-mini-instruct",
+        hf_config=dict(org="microsoft", name="Phi-3.5-mini-instruct"),
+        vocab_size=32000,
+        padded_vocab_size=32064,
+        block_size=4096,
+        n_embd=3072,
+        n_layer=32,
+        rotary_percentage=1.0,
+        bias=False,
+        norm_class_name="RMSNorm",
+        intermediate_size=8192,
+        mlp_class_name="LLaMAMLP",
+        parallel_residual=False,
+    ),
+    # https://huggingface.co/microsoft/phi-4/blob/main/config.json
+    dict(
+        name="phi-4",
+        hf_config=dict(org="microsoft", name="phi-4"),
+        vocab_size=100352,
+        padded_vocab_size=100352,
+        block_size=16384,
+        n_embd=5120,
+        n_layer=40,
+        n_head=40,
+        n_query_groups=10,
+        rotary_percentage=1.0,
+        bias=False,
+        norm_class_name="RMSNorm",
+        intermediate_size=17920,
+        rope_base=250000,
+        mlp_class_name="LLaMAMLP",
+        parallel_residual=False,
+    ),
+    # https://huggingface.co/microsoft/Phi-4-reasoning/blob/main/config.json
+    dict(
+        name="Phi-4-reasoning",
+        hf_config=dict(org="microsoft", name="Phi-4-reasoning"),
+        vocab_size=100352,
+        padded_vocab_size=100352,
+        block_size=32768,
+        n_embd=5120,
+        n_layer=40,
+        n_head=40,
+        n_query_groups=10,
+        rotary_percentage=1.0,
+        bias=False,
+        norm_class_name="RMSNorm",
+        intermediate_size=17920,
+        rope_base=500000,
+        mlp_class_name="LLaMAMLP",
+        parallel_residual=False,
+    ),
+    # https://huggingface.co/microsoft/Phi-4-reasoning-plus/blob/main/config.json
+    dict(
+        name="Phi-4-reasoning-plus",
+        hf_config=dict(org="microsoft", name="Phi-4-reasoning-plus"),
+        vocab_size=100352,
+        padded_vocab_size=100352,
+        block_size=32768,
+        n_embd=5120,
+        n_layer=40,
+        n_head=40,
+        n_query_groups=10,
+        rotary_percentage=1.0,
+        bias=False,
+        norm_class_name="RMSNorm",
+        intermediate_size=17920,
+        rope_base=500000,
+        mlp_class_name="LLaMAMLP",
+        parallel_residual=False,
+    ),
+    # https://huggingface.co/microsoft/Phi-4-mini-instruct/blob/main/config.json
+    dict(
+        name="Phi-4-mini-instruct",
+        hf_config=dict(org="microsoft", name="Phi-4-mini-instruct"),
+        vocab_size=200019,
+        padded_vocab_size=200064,
+        block_size=131072,
+        n_embd=3072,
+        n_layer=32,
+        n_head=24,
+        n_query_groups=8,
+        rotary_percentage=0.75,
+        bias=False,
+        norm_class_name="RMSNorm",
+        intermediate_size=8192,
+        mlp_class_name="LLaMAMLP",
+        parallel_residual=False,
+        sliding_window_size=262145,
+    ),
+    # https://huggingface.co/microsoft/Phi-4-mini-reasoning/blob/main/config.json
+    dict(
+        name="Phi-4-mini-reasoning",
+        hf_config=dict(org="microsoft", name="Phi-4-mini-reasoning"),
+        vocab_size=200019,
+        padded_vocab_size=200064,
+        block_size=131072,
+        n_embd=3072,
+        n_layer=32,
+        n_head=24,
+        n_query_groups=8,
+        rotary_percentage=0.75,
+        bias=False,
+        norm_class_name="RMSNorm",
+        intermediate_size=8192,
+        mlp_class_name="LLaMAMLP",
+        parallel_residual=False,
+        sliding_window_size=262145,
+    ),
+]
+configs.extend(phi)
+
+
+#############
+# Mistral AI
+#############
+
+configs.append(
+    # https://huggingface.co/mistralai/mathstral-7B-v0.1/blob/main/config.json
+    dict(
+        name="Mathstral-7B-v0.1",
+        hf_config=dict(org="mistralai", name="mathstral-7B-v0.1"),
+        padded_vocab_size=32768,
+        block_size=32768,
+        n_layer=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+        sliding_window_size=4096,
+    )
+)
+
+mistral = [
+    # https://huggingface.co/mistralai/Mistral-7B-v0.1/blob/main/config.json
+    dict(
+        name="Mistral-7B-{}v0.1",
+        hf_config=dict(org="mistralai", name="Mistral-7B-{}v0.1"),
+        padded_vocab_size=32000,
+        block_size=4096,  # should be 32768 but sliding window attention is not implemented
+        n_layer=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+        sliding_window_size=4096,
+    ),
+    # https://huggingface.co/mistralai/Mixtral-8x7B-v0.1/blob/main/config.json
+    dict(
+        name="Mixtral-8x7B-{}v0.1",
+        hf_config=dict(org="mistralai", name="Mixtral-8x7B-{}v0.1"),
+        padded_vocab_size=32000,
+        block_size=32768,
+        n_layer=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMoE",
+        intermediate_size=14336,
+        rope_base=1000000,
+        n_expert=8,
+        n_expert_per_token=2,
+    ),
+    # https://huggingface.co/mistralai/Mixtral-8x22B-Instruct-v0.1/blob/main/config.json
+    dict(
+        name="Mixtral-8x22B-{}v0.1",
+        hf_config=dict(org="mistralai", name="Mixtral-8x22B-{}v0.1"),
+        padded_vocab_size=32768,
+        block_size=65536,
+        n_layer=56,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMoE",
+        intermediate_size=16384,
+        n_head=48,
+        n_embd=6144,
+        rope_base=1000000,
+        n_expert=8,
+        n_expert_per_token=2,
+    ),
+]
+for c in mistral:
+    for kind in ("", "Instruct-"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+configs.append(
+    # https://huggingface.co/unsloth/mistral-7b-v0.2/blob/main/config.json
+    dict(
+        name="Mistral-7B-v0.2",
+        hf_config=dict(org="unsloth", name="Mistral-7B-v0.2"),
+        padded_vocab_size=32000,
+        block_size=32768,
+        n_layer=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+    )
+)
+configs.append(
+    # https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.2/blob/main/config.json
+    dict(
+        name="Mistral-7B-Instruct-v0.2",
+        hf_config=dict(org="mistralai", name="Mistral-7B-Instruct-v0.2"),
+        padded_vocab_size=32000,
+        block_size=32768,
+        n_layer=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+    )
+)
+configs.append(
+    # https://huggingface.co/mistralai/Mistral-7B-v0.3/blob/main/config.json
+    dict(
+        name="Mistral-7B-v0.3",
+        hf_config=dict(org="mistralai", name="Mistral-7B-v0.3"),
+        padded_vocab_size=32768,
+        block_size=32768,
+        n_layer=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+    )
+)
+configs.append(
+    # https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.3/blob/main/config.json
+    dict(
+        name="Mistral-7B-Instruct-v0.3",
+        hf_config=dict(org="mistralai", name="Mistral-7B-Instruct-v0.3"),
+        padded_vocab_size=32768,
+        block_size=32768,
+        n_layer=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+    )
+)
+configs.append(
+    # https://huggingface.co/mistralai/Mistral-Large-Instruct-2407/blob/main/config.json
+    dict(
+        name="Mistral-Large-Instruct-2407",
+        hf_config=dict(org="mistralai", name="Mistral-Large-Instruct-2407"),
+        padded_vocab_size=32768,
+        block_size=32768,
+        n_layer=88,
+        n_head=96,
+        n_embd=12288,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+    )
+)
+configs.append(
+    # https://huggingface.co/mistralai/Mistral-Large-Instruct-2411/blob/main/config.json
+    dict(
+        name="Mistral-Large-Instruct-2411",
+        hf_config=dict(org="mistralai", name="Mistral-Large-Instruct-2411"),
+        padded_vocab_size=32768,
+        block_size=32768,
+        n_layer=88,
+        n_head=96,
+        n_embd=12288,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        norm_eps=1e-05,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+    )
+)
+
+
+############
+# TinyLlama
+############
+tiny_llama = [
+    dict(
+        name="tiny-llama-1.1b{}",
+        hf_config=dict(org="TinyLlama", name="TinyLlama-1.1B{}"),
+        block_size=2048,
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=22,
+        n_head=32,
+        n_embd=2048,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",  # original TinyLlama use FusedRMSNorm
+        norm_eps=1e-5,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=5632,
+        n_query_groups=4,
+    )
+]
+for c in tiny_llama:
+    for kind, hf_postfix in (("", "-intermediate-step-1431k-3T"), ("-chat", "-Chat-v1.0")):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(hf_postfix)
+        configs.append(copy)
+
+
+############
+# MicroLlama
+############
+micro_llama = [
+    dict(
+        name="micro-llama-300M",
+        hf_config=dict(org="keeeeenw", name="MicroLlama"),
+        block_size=2048,
+        vocab_size=32000,
+        padding_multiple=64,
+        n_layer=12,
+        n_head=16,
+        n_embd=1024,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",  # original TinyLlama and MicroLlama use FusedRMSNorm
+        norm_eps=1e-5,
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=5632,
+        n_query_groups=4,
+    )
+]
+configs.extend(micro_llama)
+
+
+##########################
+# Trelis Function Calling
+##########################
+llama_2_function_calling = [
+    # https://huggingface.co/Trelis/Llama-2-7b-chat-hf-function-calling-v2/blob/main/config.json
+    dict(
+        name="Llama-2-7b-chat-hf-function-calling-v2",
+        hf_config=dict(org="Trelis", name="Llama-2-7b-chat-hf-function-calling-v2"),
+        padding_multiple=64,
+        n_layer=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+        norm_eps=1e-6,
+        block_size=4096,
+        vocab_size=32000,
+        n_head=32,
+        n_embd=4096,
+        rope_base=10000,
+    )
+]
+
+configs.extend(llama_2_function_calling)
+
+##########################
+# Qwen2
+##########################
+qwen_2 = [
+    # https://huggingface.co/Trelis/Llama-2-7b-chat-hf-function-calling-v2/blob/main/config.json
+    dict(
+        name="Qwen2-7B",
+        hf_config=dict(org="Qwen", name="Qwen2-7B"),
+        block_size=131072,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=28,
+        n_head=28,
+        n_embd=3584,
+        n_query_groups=4,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=18944,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+dict(
+        name="Qwen2-0.5B",
+        hf_config=dict(org="Qwen", name="Qwen2-0.5B"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=24,
+        n_head=14,
+        n_embd=896,
+        n_query_groups=2,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=4864,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+]
+
+configs.extend(qwen_2)
+
+##########
+# Qwen2.5
+##########
+qwen_2_5 = [
+    # https://huggingface.co/Qwen/Qwen2.5-0.5B/blob/main/config.json
+    dict(
+        name="Qwen2.5-0.5B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-0.5B{}"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=24,
+        n_head=14,
+        n_embd=896,
+        n_query_groups=2,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=4864,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-1.5B/blob/main/config.json
+    dict(
+        name="Qwen2.5-1.5B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-1.5B{}"),
+        block_size=131072,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=28,
+        n_head=12,
+        n_embd=1536,
+        n_query_groups=2,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8960,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-3B/blob/main/config.json
+    dict(
+        name="Qwen2.5-3B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-3B{}"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=36,
+        n_head=16,
+        n_embd=2048,
+        n_query_groups=2,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-7B/blob/main/config.json
+    dict(
+        name="Qwen2.5-7B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-7B{}"),
+        block_size=131072,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=28,
+        n_head=28,
+        n_embd=3584,
+        n_query_groups=4,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=18944,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-14B/blob/main/config.json
+    dict(
+        name="Qwen2.5-14B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-14B{}"),
+        block_size=131072,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=48,
+        n_head=40,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+        norm_eps=1e-5,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-32B/blob/main/config.json
+    dict(
+        name="Qwen2.5-32B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-32B{}"),
+        block_size=131072,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=64,
+        n_head=40,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=27648,
+        norm_eps=1e-5,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-72B/blob/main/config.json
+    dict(
+        name="Qwen2.5-72B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-72B{}"),
+        block_size=131072,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=29568,
+        norm_eps=1e-5,
+        rope_base=1000000,
+    ),
+]
+
+qwen_2_5_coder = [
+    # https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Coder-0.5B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Coder-0.5B{}"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=24,
+        n_head=14,
+        n_embd=896,
+        n_query_groups=2,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=4864,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Coder-1.5B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Coder-1.5B{}"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=28,
+        n_head=12,
+        n_embd=1536,
+        n_query_groups=2,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8960,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-Coder-3B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Coder-3B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Coder-3B{}"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=36,
+        n_head=16,
+        n_embd=2048,
+        n_query_groups=2,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-Coder-7B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Coder-7B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Coder-7B{}"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=28,
+        n_head=28,
+        n_embd=3584,
+        n_query_groups=4,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=18944,
+        norm_eps=1e-6,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-Coder-14B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Coder-14B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Coder-14B{}"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=48,
+        n_head=40,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+        norm_eps=1e-5,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-Coder-32B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Coder-32B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Coder-32B{}"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=64,
+        n_head=40,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=27648,
+        norm_eps=1e-5,
+        rope_base=1000000,
+    ),
+]
+
+qwen_2_5.extend(qwen_2_5_coder)
+
+qwen_2_5_math = [
+    # https://huggingface.co/Qwen/Qwen2.5-Math-1.5B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Math-1.5B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Math-1.5B{}"),
+        block_size=4096,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=28,
+        n_head=12,
+        n_embd=1536,
+        n_query_groups=2,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8960,
+        norm_eps=1e-6,
+        rope_base=10000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-Math-7B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Math-7B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Math-7B{}"),
+        block_size=4096,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=28,
+        n_head=28,
+        n_embd=3584,
+        n_query_groups=4,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=18944,
+        norm_eps=1e-6,
+        rope_base=10000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-Math-72B/blob/main/config.json
+    dict(
+        name="Qwen2.5-Math-72B{}",
+        hf_config=dict(org="Qwen", name="Qwen2.5-Math-72B{}"),
+        block_size=4096,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=29568,
+        norm_eps=1e-5,
+        rope_base=10000,
+    ),
+]
+
+qwen_2_5.extend(qwen_2_5_math)
+
+for c in qwen_2_5:
+    for kind in ("", "-Instruct"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+
+qwen_2_5_1m = [
+    # https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-1M/blob/main/config.json
+    dict(
+        name="Qwen2.5-7B-Instruct-1M",
+        hf_config=dict(org="Qwen", name="Qwen2.5-7B-Instruct-1M"),
+        block_size=1010000,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=28,
+        n_head=28,
+        n_embd=3584,
+        n_query_groups=4,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=18944,
+        norm_eps=1e-5,
+        rope_base=10000000,
+    ),
+    # https://huggingface.co/Qwen/Qwen2.5-14B-Instruct-1M/blob/main/config.json
+    dict(
+        name="Qwen2.5-14B-Instruct-1M",
+        hf_config=dict(org="Qwen", name="Qwen2.5-14B-Instruct-1M"),
+        block_size=1010000,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=48,
+        n_head=40,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=13824,
+        norm_eps=1e-5,
+        rope_base=10000000,
+    ),
+]
+
+configs.extend(qwen_2_5_1m)
+
+##########
+# QwQ
+##########
+qwq = [
+    # https://huggingface.co/Qwen/QwQ-32B/blob/main/config.json
+    dict(
+        name="QwQ-32B",
+        hf_config=dict(org="Qwen", name="QwQ-32B"),
+        block_size=131072,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=64,
+        n_head=40,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=27648,
+        norm_eps=1e-5,
+        rope_base=1000000,
+    ),
+    # https://huggingface.co/Qwen/QwQ-32B-Preview/blob/main/config.json
+    dict(
+        name="QwQ-32B-Preview",
+        hf_config=dict(org="Qwen", name="QwQ-32B-Preview"),
+        block_size=32768,
+        vocab_size=151643,
+        padded_vocab_size=152064,
+        n_layer=64,
+        n_head=40,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        attn_bias=True,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=27648,
+        norm_eps=1e-5,
+        rope_base=1000000,
+    ),
+]
+
+configs.extend(qwq)
+
+##########
+# Qwen3
+##########
+qwen_3 = [
+    # https://huggingface.co/Qwen/Qwen3-0.6B/blob/main/config.json
+    dict(
+        name="Qwen3-0.6B{}",
+        hf_config=dict(org="Qwen", name="Qwen3-0.6B{}"),
+        block_size=40960,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=28,
+        n_head=16,
+        n_embd=1024,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=3072,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        head_size=128,
+        norm_qk=True,
+    ),
+    # https://huggingface.co/Qwen/Qwen3-1.7B/blob/main/config.json
+    dict(
+        name="Qwen3-1.7B{}",
+        hf_config=dict(org="Qwen", name="Qwen3-1.7B{}"),
+        block_size=40960,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=28,
+        n_head=16,
+        n_embd=2048,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=6144,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        norm_qk=True,
+    ),
+    # https://huggingface.co/Qwen/Qwen3-4B/blob/main/config.json
+    dict(
+        name="Qwen3-4B{}",
+        hf_config=dict(org="Qwen", name="Qwen3-4B{}"),
+        block_size=40960,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=36,
+        n_head=32,
+        n_embd=2560,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=9728,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        head_size=128,
+        norm_qk=True,
+    ),
+    # https://huggingface.co/Qwen/Qwen3-8B/blob/main/config.json
+    dict(
+        name="Qwen3-8B{}",
+        hf_config=dict(org="Qwen", name="Qwen3-8B{}"),
+        block_size=40960,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=36,
+        n_head=32,
+        n_embd=4096,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=12288,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        norm_qk=True,
+    ),
+    # https://huggingface.co/Qwen/Qwen3-14B/blob/main/config.json
+    dict(
+        name="Qwen3-14B{}",
+        hf_config=dict(org="Qwen", name="Qwen3-14B{}"),
+        block_size=40960,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=40,
+        n_head=40,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=17408,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        norm_qk=True,
+    ),
+]
+for c in qwen_3:
+    for kind in ("", "-Base"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+qwen_3_32b = [
+    # https://huggingface.co/Qwen/Qwen3-32B/blob/main/config.json
+    dict(
+        name="Qwen3-32B",
+        hf_config=dict(org="Qwen", name="Qwen3-32B"),
+        block_size=40960,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=64,
+        n_head=64,
+        n_embd=5120,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=25600,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        head_size=128,
+        norm_qk=True,
+    ),
+]
+configs.extend(qwen_3_32b)
+
+qwen_3_moe = [
+    # https://huggingface.co/Qwen/Qwen3-30B-A3B/blob/main/config.json
+    dict(
+        name="Qwen3-30B-A3B",
+        hf_config=dict(org="Qwen", name="Qwen3-30B-A3B"),
+        block_size=40960,
+        head_size=128,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=48,
+        n_head=32,
+        n_embd=2048,
+        n_query_groups=4,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMoE",
+        intermediate_size=6144,
+        moe_intermediate_size=768,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        norm_qk=True,
+        n_expert=128,
+        n_expert_per_token=8,
+    ),
+    # https://huggingface.co/Qwen/Qwen3-30B-A3B-Base/blob/main/config.json
+    dict(
+        name="Qwen3-30B-A3B-Base",
+        hf_config=dict(org="Qwen", name="Qwen3-30B-A3B-Base"),
+        block_size=40960,
+        head_size=128,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=48,
+        n_head=32,
+        n_embd=2048,
+        n_query_groups=4,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMoE",
+        intermediate_size=6144,
+        moe_intermediate_size=768,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        norm_qk=True,
+        n_expert=128,
+        n_expert_per_token=8,
+    ),
+    # https://huggingface.co/Qwen/Qwen3-235B-A22B/blob/main/config.json
+    dict(
+        name="Qwen3-235B-A22B",
+        hf_config=dict(org="Qwen", name="Qwen3-235B-A22B"),
+        block_size=40960,
+        head_size=128,
+        vocab_size=151643,
+        padded_vocab_size=151936,
+        n_layer=94,
+        n_head=64,
+        n_embd=4096,
+        n_query_groups=4,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMoE",
+        intermediate_size=12288,
+        moe_intermediate_size=1536,
+        norm_eps=1e-6,
+        rope_base=1000000,
+        norm_qk=True,
+        n_expert=128,
+        n_expert_per_token=8,
+    ),
+]
+configs.extend(qwen_3_moe)
+
+
+#############
+# Salamandra
+#############
+salamandra = [
+    # https://huggingface.co/BSC-LT/salamandra-2b-instruct/blob/main/config.json
+    dict(
+        name="salamandra-2b{}",
+        hf_config=dict(org="BSC-LT", name="salamandra-2b{}"),
+        block_size=8192,
+        vocab_size=256000,
+        padded_vocab_size=256000,
+        n_layer=24,
+        n_head=16,
+        n_embd=2048,
+        n_query_groups=16,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=5440,
+        norm_eps=1e-5,
+        rope_base=10000,
+    ),
+    # https://huggingface.co/BSC-LT/salamandra-7b-instruct/blob/main/config.json
+    dict(
+        name="salamandra-7b{}",
+        hf_config=dict(org="BSC-LT", name="salamandra-7b{}"),
+        block_size=8192,
+        vocab_size=256000,
+        padded_vocab_size=256000,
+        n_layer=32,
+        n_head=32,
+        n_embd=4096,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=11008,
+        norm_eps=1e-6,
+        rope_base=10000,
+    ),
+]
+
+for c in salamandra:
+    for kind in ("", "-instruct"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+
+
+###############
+# SmolLM2
+###############
+smollm2 = [
+    # https://huggingface.co/HuggingFaceTB/SmolLM2-135M/blob/main/config.json
+    dict(
+        name="SmolLM2-135M{}",
+        hf_config=dict(org="HuggingFaceTB", name="SmolLM2-135M{}"),
+        block_size=8192,
+        vocab_size=49152,
+        padded_vocab_size=49152,
+        n_layer=30,
+        n_head=9,
+        n_embd=576,
+        n_query_groups=3,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=1536,
+        rope_base=100000,
+        norm_eps=1e-5,
+    ),
+    # https://huggingface.co/HuggingFaceTB/SmolLM2-360M/blob/main/config.json
+    dict(
+        name="SmolLM2-360M{}",
+        hf_config=dict(org="HuggingFaceTB", name="SmolLM2-360M{}"),
+        block_size=8192,
+        vocab_size=49152,
+        padded_vocab_size=49152,
+        n_layer=32,
+        n_head=15,
+        n_embd=960,
+        n_query_groups=5,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=2560,
+        rope_base=100000,
+        norm_eps=1e-5,
+    ),
+    # https://huggingface.co/HuggingFaceTB/SmolLM2-1.7B/blob/main/config.json
+    dict(
+        name="SmolLM2-1.7B{}",
+        hf_config=dict(org="HuggingFaceTB", name="SmolLM2-1.7B{}"),
+        block_size=8192,
+        vocab_size=49152,
+        padded_vocab_size=49152,
+        n_layer=24,
+        n_head=32,
+        n_embd=2048,
+        n_query_groups=32,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=8192,
+        rope_base=130000,
+        norm_eps=1e-5,
+    ),
+]
+
+for c in smollm2:
+    for kind in ("", "-Instruct"):
+        copy = deepcopy(c)
+        copy["name"] = c["name"].format(kind)
+        copy["hf_config"]["name"] = c["hf_config"]["name"].format(kind)
+        configs.append(copy)
+
+###############
+# DeepSeek R1 Distill
+###############
+
+r1_distill_llama = [
+    # https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B/blob/main/config.json
+    dict(
+        name="R1-Distill-Llama-8B",
+        hf_config=dict(org="deepseek-ai", name="DeepSeek-R1-Distill-Llama-8B"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=32,
+        n_head=32,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=14336,
+        rope_base=500000,
+        rope_adjustments=dict(factor=8.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+    # https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B/blob/main/config.json
+    dict(
+        name="R1-Distill-Llama-70B",
+        hf_config=dict(org="deepseek-ai", name="DeepSeek-R1-Distill-Llama-70B"),
+        block_size=131072,
+        vocab_size=128000,
+        padded_vocab_size=128256,
+        n_layer=80,
+        n_head=64,
+        n_embd=8192,
+        n_query_groups=8,
+        rotary_percentage=1.0,
+        parallel_residual=False,
+        bias=False,
+        norm_class_name="RMSNorm",
+        mlp_class_name="LLaMAMLP",
+        intermediate_size=28672,
+        rope_base=500000,
+        rope_adjustments=dict(factor=8.0, low_freq_factor=1.0, high_freq_factor=4.0, original_max_seq_len=8192),
+    ),
+]
+
+configs.extend(r1_distill_llama)
+
+name_to_config = {config["name"]: config for config in configs}

litgpt/lora.py

@@ -0,0 +1,662 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+# Derived from https://github.com/microsoft/LoRA
+#  ------------------------------------------------------------------------------------------
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.
+#  ------------------------------------------------------------------------------------------
+
+r"""
+    Low Ranking Adaptation for LLMs scheme.
+
+             ┌───────────────────┐
+             ┆         h         ┆
+             └───────────────────┘
+                       ▲
+                       |
+                       +
+                    /     \
+    ┌─────────────────┐    ╭───────────────╮     Matrix initialization:
+    ┆                 ┆     \      B      /      B = 0
+    ┆   pretrained    ┆      \    r*d    /       A = N(0, sigma^2)
+    ┆    weights      ┆       ╰─────────╯
+    ┆                 ┆       |    r    |        r - rank
+    ┆   W e R^(d*d)   ┆       | ◀─────▶ |
+    ┆                 ┆       ╭─────────╮
+    └─────────────────┘      /     A     \
+              ▲             /     d*r     \
+               \           ╰───────────────╯
+                \                ▲
+                 \              /
+                  \            /
+             ┌───────────────────┐
+             ┆         x         ┆
+             └───────────────────┘
+
+With LoRA (Low Ranking Adaptation: https://arxiv.org/abs/2106.09685) instead of learning weights of size d*d,
+we can freeze the pretrained weights and instead learn two matrices of size d*r and r*d (they will store weight updates
+for the pretrained weights): the number of parameters in this case will be reduced drastically (depending on the rank of
+course) yet after multiplication of matrices d*r and r*d we will get a matrix d*d which we can sum with frozen
+pretrained weights and thus fine-tune the model.
+
+The goal of this approach is to move weight updates into a separate matrix which is decomposed with
+two matrices of a lower rank.
+"""
+
+import math
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple, Type, Union
+
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+from typing_extensions import Self
+
+import litgpt
+from litgpt.config import Config as BaseConfig
+from litgpt.model import GPT as BaseModel
+from litgpt.model import Block as BaseBlock
+from litgpt.model import CausalSelfAttention as BaseCausalSelfAttention
+from litgpt.scripts.convert_hf_checkpoint import qkv_reassemble
+from litgpt.utils import map_old_state_dict_weights
+
+
+class LoRALayer(nn.Module):
+    def __init__(self, r: int, lora_alpha: int, lora_dropout: float):
+        """Store LoRA specific attributes in a class.
+
+        Args:
+            r: rank of the weight update matrices. To make sense of using LoRA the rank should be smaller than the rank of
+                the weights of the model. The rank can be as low as 1: https://arxiv.org/pdf/2106.09685.pdf (section 7.2)
+            lora_alpha: alpha is needed for scaling updates as alpha/r
+                "This scaling helps to reduce the need to retune hyperparameters when we vary r"
+                https://arxiv.org/pdf/2106.09685.pdf (section 4.1)
+            lora_dropout: dropout that is applied on the input in the LoRA branch (before multiplying by matrix A)
+        """
+        super().__init__()
+        assert r >= 0
+        self.r = r
+        self.lora_alpha = lora_alpha
+        # Optional dropout
+        if lora_dropout > 0.0:
+            self.lora_dropout = nn.Dropout(p=lora_dropout)
+        else:
+            self.lora_dropout = lambda x: x
+        # Mark the weight as unmerged
+        self.merged = False
+
+
+class LoRALinear(LoRALayer):
+    # LoRA implemented in a dense layer
+    def __init__(
+        self,
+        # ↓ this part is for pretrained weights
+        in_features: int,
+        out_features: int,
+        # ↓ the remaining part is for LoRA
+        r: int = 0,
+        lora_alpha: int = 1,
+        lora_dropout: float = 0.0,
+        **kwargs: Any,
+    ):
+        """LoRA wrapper around linear class.
+
+        This class has three weight matrices:
+            1. Pretrained weights are stored as `self.linear.weight`
+            2. LoRA A matrix as `self.lora_A`
+            3. LoRA B matrix as `self.lora_B`
+        Only LoRA's A and B matrices are updated, pretrained weights stay frozen.
+
+        Args:
+            in_features: number of input features of the pretrained weights
+            out_features: number of output features of the pretrained weights
+            r: rank of the weight update matrices. To make sense of using LoRA the rank should be smaller than the rank of
+                the weights of the model. The rank can be as low as 1: https://arxiv.org/pdf/2106.09685.pdf (section 7.2)
+            lora_alpha: alpha is needed for scaling updates as alpha/r
+                "This scaling helps to reduce the need to retune hyperparameters when we vary r"
+                https://arxiv.org/pdf/2106.09685.pdf (section 4.1)
+            lora_dropout: dropout that is applied on the input in the LoRA branch (before multiplying by matrix A)
+        """
+        super().__init__(r=r, lora_alpha=lora_alpha, lora_dropout=lora_dropout)
+        self.linear = torch.nn.Linear(in_features, out_features, **kwargs)
+
+        # Actual trainable parameters
+        if r > 0:
+            self.lora_A = nn.Parameter(torch.empty((r, in_features)))
+            self.lora_B = nn.Parameter(torch.empty((out_features, r)))
+            self.scaling = self.lora_alpha / self.r
+            self.reset_parameters()
+
+    def reset_parameters(self) -> None:
+        """Reset all the weights, even including pretrained ones."""
+        if hasattr(self, "lora_A"):
+            # initialize A the same way as the default for nn.Linear and B to zero
+            # Wondering why 'a' is equal to math.sqrt(5)?: https://github.com/pytorch/pytorch/issues/15314
+            nn.init.kaiming_uniform_(self.lora_A, a=math.sqrt(5))
+            nn.init.zeros_(self.lora_B)
+
+    def get_lora_AB(self) -> torch.Tensor:
+        """Return merged lora_A and lora_B matrices with the same shape as the pretrained weights."""
+        return (self.lora_B @ self.lora_A) * self.scaling
+
+    def merge(self) -> None:
+        """Merges the LoRA weights into the full-rank weights (W = W + delta_W)."""
+        if self.r > 0 and not self.merged:
+            pretrained_dtype = self.linear.weight.data.dtype
+            lora_data = self.get_lora_AB()
+            # if only the pretrained are in quantized form - dequantize, sum with LoRA and quantize the result
+            if pretrained_dtype == torch.uint8:
+                import bitsandbytes as bnb
+
+                weight = self.linear.weight
+                # dequantize the pretrained weights
+                weight_data = bnb.functional.dequantize_4bit(weight.data, weight.quant_state).to(lora_data.dtype)
+                # add pretrained and LoRA weights
+                weight_data += lora_data
+                # assign updated weights and quantize by moving to CUDA device
+                self.linear.weight = bnb.nn.Params4bit(weight_data, requires_grad=False, **weight.__dict__)
+                self.linear.weight.cuda(weight.device)
+            else:
+                # self.linear might be on CPU and lora_data on CUDA
+                # the inplace add will preserve the dtype of linear.weight
+                self.linear.weight.data += lora_data.to(device=self.linear.weight.data.device)
+            self.merged = True
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # if weights are merged or rank is less or equal to zero (LoRA is disabled) - it's only a regular nn.Linear forward pass;
+        # otherwise in addition do the forward pass with LoRA weights and add it's output to the output from pretrained weights
+        pretrained = self.linear(x)
+        if self.r == 0 or self.merged:
+            return pretrained
+        lora = (self.lora_dropout(x) @ self.lora_A.transpose(0, 1) @ self.lora_B.transpose(0, 1)) * self.scaling
+        return pretrained + lora
+
+
+class LoRAQKVLinear(LoRALinear):
+    # LoRA implemented in a dense layer
+    def __init__(
+        self,
+        # ↓ this part is for pretrained weights
+        in_features: int,
+        out_features: int,
+        # ↓ the remaining part is for LoRA
+        head_size: int,
+        n_head: int,
+        n_query_groups: int,
+        r: int = 0,
+        lora_alpha: int = 1,
+        lora_dropout: float = 0.0,
+        enable_lora: Union[bool, Tuple[bool, bool, bool]] = False,
+        **kwargs: Any,
+    ):
+        """LoRA wrapper around linear class that is used for calculation of q, k and v matrices.
+
+        This class has three weight matrices:
+            1. Pretrained weights are stored as `self.linear.weight`
+            2. LoRA A matrix as `self.lora_A`
+            3. LoRA B matrix as `self.lora_B`
+        Only LoRA's A and B matrices are updated, pretrained weights stay frozen.
+
+        Args:
+            in_features: number of input features of the pretrained weights
+            out_features: number of output features of the pretrained weights
+            head_size: size of a single attention head
+            n_head: number of attention heads
+            n_query_groups: number of query groups (see diagram in `litgpt/config.py`)
+            r: rank of the weight update matrices. To make sense of using LoRA the rank should be smaller than the rank of
+                the weights of the model. The rank can be as low as 1: https://arxiv.org/pdf/2106.09685.pdf (section 7.2)
+            lora_alpha: alpha is needed for scaling updates as alpha/r
+                "This scaling helps to reduce the need to retune hyperparameters when we vary r"
+                https://arxiv.org/pdf/2106.09685.pdf (section 4.1)
+            lora_dropout: dropout that is applied on the input in the LoRA branch (before multiplying by matrix A)
+            enable_lora: MergeLinear class is for attention mechanism where qkv are calculated with a single weight matrix. If we
+                don't want to apply LoRA we can set it as False. For example if we want to apply LoRA only to `query`
+                and `value` but keep `key` without weight updates we should pass `[True, False, True]`
+        """
+        super(LoRALinear, self).__init__(r=r, lora_alpha=lora_alpha, lora_dropout=lora_dropout)
+        self.linear = torch.nn.Linear(in_features, out_features, **kwargs)
+        self.head_size = head_size
+        self.n_head = n_head
+        self.n_query_groups = n_query_groups
+        if isinstance(enable_lora, bool):
+            enable_lora = [enable_lora] * 3
+        assert len(enable_lora) == 3
+        self.enable_lora = enable_lora
+
+        # Actual trainable parameters
+        # To better understand initialization let's imagine that we have such parameters:
+        # ⚬ in_features: 128 (embeddings_size)
+        # ⚬ out_features: 384 (3 * embedding_size)
+        # ⚬ r: 2
+        # ⚬ enable_lora: [True, False, True]
+        if r > 0 and any(enable_lora):
+            self.lora_A = nn.Parameter(torch.empty((r * sum(enable_lora), in_features)))  # (4, 128)
+            enable_q, enable_k, enable_v = enable_lora
+            # qkv_shapes will be used to split a tensor with weights correctly
+            qkv_shapes = (
+                # if `head_size` is explicitly specified in the config, `n_embd` (or `in_features`)
+                # might not be equal to `head_size * n_head`, thus we use it directly here
+                head_size * n_head * enable_q,
+                head_size * n_query_groups * enable_k,
+                head_size * n_query_groups * enable_v,
+            )
+            self.qkv_shapes = [s for s in qkv_shapes if s]
+            self.lora_B = nn.Parameter(torch.empty(sum(self.qkv_shapes), r))  # (256, 2))
+            # Notes about shapes above
+            # - self.lora_A has shape (4, 128): 4 because rank is 2 and LoRA is applied only to two matrices;
+            # 128 is the input size of the x (embedding size). (4, 128) and not (128, 4) because later on in
+            # F.linear function weights are automatically transposed. In addition conv1d requires channels to
+            # be before seq length
+            # - self.lora_B has shape (256, 2): 256 because LoRA is applied only to two matrices, so the output is
+            # 128*2; 2 tells to have two channels per group for group convolution
+
+            # Scaling:
+            # This balances the pretrained model`s knowledge and the new task-specific adaptation
+            # https://lightning.ai/pages/community/tutorial/lora-llm/
+            # So, set alpha to 1.0 to fully add LoRA. If the LoRA seems to have too much effect (i.e., overfitted), set
+            # alpha to lower value. If the LoRA seems to have too little effect, set alpha to higher than 1.0. You can
+            # tune these values to your needs. This value can be even slightly greater than 1.0!
+            # https://github.com/cloneofsimo/lora
+            self.scaling = self.lora_alpha / self.r
+
+            self.reset_parameters()
+
+    @property
+    def lora_ind(self) -> torch.Tensor:
+        """Lazy creation of a buffer with LoRA indices to overcome the limitation when FSDP with meta device is used."""
+        # Indices are needed to properly pad weight updates with zeros.
+        if not hasattr(self, "_lora_ind"):
+            enable_q, enable_k, enable_v = self.enable_lora
+            kv_embd_size = self.linear.in_features // (self.n_head // self.n_query_groups)
+            lora_ind = []
+            if enable_q:
+                lora_ind.extend(range(0, self.linear.in_features))
+            if enable_k:
+                lora_ind.extend(range(self.linear.in_features, self.linear.in_features + kv_embd_size))
+            if enable_v:
+                lora_ind.extend(range(self.linear.in_features + kv_embd_size, self.linear.out_features))
+            self.register_buffer(
+                "_lora_ind", torch.tensor(lora_ind, device=self.linear.weight.device), persistent=False
+            )
+
+        return self._lora_ind
+
+    def zero_pad(self, x: torch.Tensor) -> torch.Tensor:
+        """Properly pad the last dimension of weight updates with zeros.
+
+        If, based on `self.enable_lora`, we want to fine-tune queries and values, but not keys,
+        then the weights update should be:
+
+        [[ΔW,ΔW,ΔW, ..., 0,0,0, ..., ΔW,ΔW,ΔW,],
+         [....................................],
+         [ΔW,ΔW,ΔW, ..., 0,0,0, ..., ΔW,ΔW,ΔW,]]
+            ↑              ↑            ↑
+        ________________________________________
+        | query         | key       | value    |
+        ----------------------------------------
+
+        Args:
+            x: tensor with weights update that will be padded with zeros if necessary
+
+        Returns:
+            A tensor with weight updates and zeros for deselected q, k or v
+        """
+        # we need to do zero padding only if LoRA is disabled for one of QKV matrices
+        if all(self.enable_lora):
+            return x
+
+        # Let's image that:
+        # ⚬ input x has shape (64, 64, 256): (batch_size, sequence_length, embeddings_size)
+        # ⚬ embeddings_size: 128
+        # ⚬ self.linear.out_features: 384 (3 * embeddings_size)
+        # ⚬ enable_lora: [True, False, True]
+        # Then x has embeddings_size of 256 (2 * 128 as enable_lora only for query and value, not keys) and expected
+        # embeddings_size is 384 (self.linear.out_features), so that means that we need to pad from 256 to 384 with zeros, but
+        # only for key updates (this is where self.lora_ind comes in handy)
+
+        result = x.new_zeros(*x.shape[:-1], self.linear.out_features)  # (64, 64, 384)
+        if result.device.type == "mps":
+            result[..., self.lora_ind] = x
+            return result
+        else:
+            return result.index_copy_(dim=-1, index=self.lora_ind, source=x)  # (64, 64, 384)
+
+    def conv1d(self, input: torch.Tensor, weight: torch.Tensor) -> torch.Tensor:
+        """An extension of the `torch.nn.functional.conv1d` function with a logic specific to grouped queries.
+
+        If the number of heads is equal to the number of query groups - grouped queries are disabled
+        (see scheme in `litgpt/config.py:Config`). In this case the combined QKV matrix consists of equally sized
+        query, key and value parts, which means we can utilize `groups` argument from `conv1d`: with this argument the
+        input and weight matrices will be split in equally sized parts and applied separately (like having multiple
+        conv layers side by side).
+
+        Otherwise QKV matrix consists of unequally sized parts and thus we have to split input and weight matrices manually,
+        apply each part of the weight matrix to the corresponding input's part and concatenate the result.
+
+        Args:
+            input: input matrix of shape (B, C, T)
+            weight: weight matrix of shape (C_output, rank, 1).
+                "C_output" is defined as a sum of embedding sizes for each enabled LoRA layer (see init method of the class).
+
+        Returns:
+            A tensor with a shape (B, C_output, T)
+
+        """
+        if self.n_head == self.n_query_groups:
+            return F.conv1d(input, weight, groups=sum(self.enable_lora))  # (B, C_output, T)
+
+        # Notation:
+        # ⚬ N: number of enabled LoRA layers (self.enable_lora)
+        # ⚬ C_output': embeddings size for each LoRA layer (not equal in size)
+        # ⚬ r: rank of all LoRA layers (equal in size)
+
+        input_splitted = input.chunk(sum(self.enable_lora), dim=1)  # N * (B, C // N, T)
+        weight_splitted = weight.split(self.qkv_shapes)  # N * (C_output', r, 1)
+        return torch.cat(
+            [F.conv1d(a, b) for a, b in zip(input_splitted, weight_splitted)],
+            dim=1,  # (B, C_output', T)
+        )  # (B, C_output, T)
+
+    def get_lora_AB(self) -> torch.Tensor:
+        """Return merged lora_A and lora_B matrices with the same shape as the pretrained weights."""
+        # Let's assume that:
+        # ⚬ self.linear.weight.data: (384, 128) or (3 * embedding_size, embedding_size)
+        # ⚬ self.lora_A.data: (4, 128)
+        # ⚬ self.lora_B.data: (256, 2)
+        lora = self.conv1d(
+            self.lora_A.data.unsqueeze(0),  # (4, 128) -> (1, 4, 128)
+            self.lora_B.data.unsqueeze(-1),  # (256, 2) -> (256, 2, 1)
+        ).squeeze(0)  # (1, 4, 128) @ (256, 2, 1) -> (1, 256, 128) -> (256, 128)
+        return self.zero_pad(lora.T * self.scaling).T  # (256, 128) after zero_pad (384, 128)
+
+    def merge(self) -> None:
+        """Merges the LoRA weights into the full-rank weights (W = W + delta_W)."""
+        if self.r > 0 and any(self.enable_lora) and not self.merged:
+            super().merge()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Do the forward pass.
+
+        If LoRA's weights are merged with pretrained ones then it's a simple matrix multiplication.
+        If not, then multiply pretrained weights with input, apply LoRA on input and do summation.
+
+        Args:
+            x: input tensor of shape (batch_size, context_length, embedding_size)
+
+        Returns:
+            Output tensor of shape (batch_size, context_length, 3 * embedding_size)
+        """
+
+        # Let's assume that:
+        # ⚬ x: (64, 64, 128) or (batch_size, context_length, embedding_size)
+        # ⚬ self.linear.weight: (384, 128) or (3 * embedding_size, embedding_size)
+        # ⚬ self.lora_A.data: (4, 128)
+        # ⚬ self.lora_B.data: (256, 2)
+
+        # if weights are merged or LoRA is disabled (r <= 0 or all `enable_lora` are False) - it's only a regular nn.Linear forward pass;
+        # otherwise in addition do the forward pass with LoRA weights and add it's output to the output from pretrained weights
+        pretrained = self.linear(x)
+        if self.r == 0 or not any(self.enable_lora) or self.merged:
+            return pretrained
+        after_A = F.linear(self.lora_dropout(x), self.lora_A)  # (64, 64, 128) @ (4, 128) -> (64, 64, 4)
+        # For F.conv1d:
+        # ⚬ input: input tensor of shape (mini-batch, in_channels, iW)
+        # ⚬ weight: filters of shape (out_channels, in_channels/groups, kW)
+        after_B = self.conv1d(
+            after_A.transpose(-2, -1),  # (64, 64, 4) -> (64, 4, 64)
+            self.lora_B.unsqueeze(-1),  # (256, 2) -> (256, 2, 1)
+        ).transpose(-2, -1)  # (64, 4, 64) @ (256, 2, 1) -> (64, 256, 64) -> (64, 64, 256)
+        lora = self.zero_pad(after_B) * self.scaling  # (64, 64, 256) after zero_pad (64, 64, 384)
+        return pretrained + lora
+
+
+def mark_only_lora_as_trainable(model: nn.Module, bias: str = "none") -> None:
+    """Freeze all modules except LoRA's and depending on 'bias' value unfreezes bias weights.
+
+    Args:
+        model: model with LoRA layers
+        bias:
+            ``"none"``: all bias weights will be frozen,
+            ``"lora_only"``: only bias weight for LoRA layers will be unfrozen,
+            ``"all"``: all bias weights will be unfrozen.
+
+    Raises:
+        NotImplementedError: if `bias` not in ["none", "lora_only", "all"]
+    """
+    # freeze all layers except LoRA's
+    for n, p in model.named_parameters():
+        if "lora_" not in n:
+            p.requires_grad = False
+
+    # depending on the `bias` value unfreeze bias weights
+    if bias == "none":
+        return
+    if bias == "all":
+        for n, p in model.named_parameters():
+            if "bias" in n:
+                p.requires_grad = True
+    elif bias == "lora_only":
+        for m in model.modules():
+            if isinstance(m, LoRALayer) and hasattr(m, "bias") and m.bias is not None:
+                m.bias.requires_grad = True
+    else:
+        raise NotImplementedError
+
+
+def lora_filter(key: str, value: Any) -> bool:
+    return "lora_" in key
+
+
+@dataclass
+class Config(BaseConfig):
+    """
+    Args:
+        lora_r: rank of the weight update matrices. To make sense of using LoRA the rank should be smaller than the rank of
+            the weights of the model. The rank can be as low as 1: https://arxiv.org/pdf/2106.09685.pdf (section 7.2)
+        lora_alpha: alpha is needed for scaling updates as alpha/r
+            "This scaling helps to reduce the need to retune hyperparameters when we vary r"
+            https://arxiv.org/pdf/2106.09685.pdf (section 4.1)
+        lora_dropout: dropout that is applied on the input in the LoRA branch (before multiplying by matrix A)
+        lora_*: whether to apply LoRA to the specified weights or not
+    """
+
+    lora_r: int = 0
+    lora_alpha: int = 1
+    lora_dropout: float = 0.0
+    lora_query: bool = False
+    lora_key: bool = False
+    lora_value: bool = False
+    lora_projection: bool = False
+    lora_mlp: bool = False
+    lora_head: bool = False
+
+    @property
+    def mlp_class(self) -> Type:
+        return getattr(litgpt.lora, self.mlp_class_name)
+
+
+class GPT(BaseModel):
+    # Copy & paste from :class:`model.GPT`. Note that :class:`Block` is new here.
+    def __init__(self, config: Config) -> None:
+        nn.Module.__init__(self)
+        assert config.padded_vocab_size is not None
+        self.config = config
+
+        self.lm_head = create_lora_linear(
+            config,
+            config.n_embd,
+            config.padded_vocab_size,
+            bias=config.lm_head_bias,
+            use_r=config.lora_head,
+        )
+        self.transformer = nn.ModuleDict(
+            dict(
+                wte=nn.Embedding(config.padded_vocab_size, config.n_embd),
+                h=nn.ModuleList(Block(config, block_idx) for block_idx in range(config.n_layer)),
+                ln_f=config.norm_class(config.n_embd, eps=config.norm_eps),
+            )
+        )
+        self.mask_cache: Optional[torch.Tensor] = None
+        self.max_seq_length = self.config.block_size
+
+    @classmethod
+    def from_name(cls, name: str, **kwargs: Any) -> Self:
+        return cls(Config.from_name(name, **kwargs))
+
+    def _init_weights(self, module: nn.Module) -> None:
+        """Meant to be used with `gpt.apply(gpt._init_weights)`. Unused method left for completeness."""
+        super()._init_weights(module)
+        if isinstance(module, LoRALinear):
+            module.reset_parameters()
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base checkpoints."""
+        mapping = {"lm_head.weight": "lm_head.linear.weight", "lm_head.bias": "lm_head.linear.bias"}
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+class Block(BaseBlock):
+    def __init__(self, config: Config, block_idx: int) -> None:
+        super().__init__(config, block_idx)
+        self.attn = CausalSelfAttention(config, block_idx)
+        self.mlp = config.mlp_class(config)
+
+
+class CausalSelfAttention(BaseCausalSelfAttention):
+    def __init__(self, config: Config, block_idx: int) -> None:
+        super().__init__(config, block_idx)
+        # key, query, value projections for all heads, but in a batch
+        shape = (config.n_head + 2 * config.n_query_groups) * config.head_size
+        self.qkv = LoRAQKVLinear(
+            in_features=config.n_embd,
+            out_features=shape,
+            r=config.lora_r,
+            lora_alpha=config.lora_alpha,
+            lora_dropout=config.lora_dropout,
+            enable_lora=(config.lora_query, config.lora_key, config.lora_value),
+            bias=config.bias or config.attn_bias,
+            # for MQA/GQA support
+            head_size=config.head_size,
+            n_head=config.n_head,
+            n_query_groups=config.n_query_groups,
+        )
+        # output projection
+        self.proj = create_lora_linear(
+            config,
+            config.head_size * config.n_head,
+            config.n_embd,
+            use_r=config.lora_projection,
+        )
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base and/or legacy checkpoints."""
+        mapping = {
+            "qkv.weight": "qkv.linear.weight",
+            "qkv.bias": "qkv.linear.bias",
+            "proj.weight": "proj.linear.weight",
+            "proj.bias": "proj.linear.bias",
+        }
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+
+        for attr in ("weight", "bias"):
+            legacy_key = f"{prefix}attn.linear.{attr}"
+            current_key = f"{prefix}qkv.linear.{attr}"
+            if legacy_key in state_dict:
+                state_dict[current_key] = qkv_reassemble(state_dict.pop(legacy_key), self.config)
+
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+def create_lora_linear(
+    config: Config,
+    in_size: int,
+    out_size: int,
+    bias: Optional[Union[float, bool]] = None,
+    use_r: Optional[bool] = None,
+) -> LoRALinear:
+    if bias is None:
+        bias = config.bias
+    if use_r is None:
+        use_r = config.lora_mlp
+    return LoRALinear(
+        in_size,
+        out_size,
+        bias=bias,
+        r=(config.lora_r if use_r else 0),
+        lora_alpha=config.lora_alpha,
+        lora_dropout=config.lora_dropout,
+    )
+
+
+class GptNeoxMLP(litgpt.model.GptNeoxMLP):
+    def __init__(self, config: Config) -> None:
+        nn.Module.__init__(self)
+        self.fc = create_lora_linear(config, config.n_embd, config.intermediate_size)
+        self.proj = create_lora_linear(config, config.intermediate_size, config.n_embd)
+        self.config = config
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base checkpoints."""
+        mapping = {
+            "fc.weight": "fc.linear.weight",
+            "fc.bias": "fc.linear.bias",
+            "proj.weight": "proj.linear.weight",
+            "proj.bias": "proj.linear.bias",
+        }
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+class LLaMAMLP(litgpt.model.LLaMAMLP):
+    def __init__(self, config: Config, intermediate_size: Optional[int] = None) -> None:
+        nn.Module.__init__(self)
+        self.intermediate_size = intermediate_size or config.intermediate_size
+        self.fc_1 = create_lora_linear(config, config.n_embd, self.intermediate_size)
+        self.fc_2 = create_lora_linear(config, config.n_embd, self.intermediate_size)
+        self.proj = create_lora_linear(config, self.intermediate_size, config.n_embd)
+        self.config = config
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base checkpoints."""
+        mapping = {
+            "fc_1.weight": "fc_1.linear.weight",
+            "fc_1.bias": "fc_1.linear.bias",
+            "fc_2.weight": "fc_2.linear.weight",
+            "fc_2.bias": "fc_2.linear.bias",
+            "proj.weight": "proj.linear.weight",
+            "proj.bias": "proj.linear.bias",
+        }
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+class GemmaMLP(LLaMAMLP):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x_fc_1 = self.fc_1(x)
+        x_fc_2 = self.fc_2(x)
+        x = torch.nn.functional.gelu(x_fc_1, approximate=self.config.gelu_approximate) * x_fc_2
+        return self.proj(x)
+
+
+class LLaMAMoE(litgpt.model.LLaMAMoE):
+    def __init__(self, config: Config) -> None:
+        nn.Module.__init__(self)
+        self.gate = create_lora_linear(config, config.n_embd, config.n_expert, bias=False)
+        self.experts = nn.ModuleList(
+            LLaMAMLP(config, intermediate_size=config.moe_intermediate_size) for _ in range(config.n_expert)
+        )
+        self.config = config
+
+    def _load_from_state_dict(self, state_dict: Dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with base checkpoints."""
+        mapping = {"gate.weight": "gate.linear.weight"}
+        state_dict = map_old_state_dict_weights(state_dict, mapping, prefix)
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+def merge_lora_weights(model: GPT) -> None:
+    """Merge LoRA weights into the full-rank weights to speed up inference."""
+    for module in model.modules():
+        if isinstance(module, LoRALinear):
+            module.merge()

litgpt/model.py

@@ -0,0 +1,876 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+"""Full definition of a decoder-only transformer-based language model, all of it in this single file.
+
+Based on the nanoGPT implementation: https://github.com/karpathy/nanoGPT and
+https://github.com/EleutherAI/gpt-neox/tree/main/megatron/model.
+"""
+
+import math
+from functools import partial
+from typing import Any, List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing_extensions import Self
+
+from litgpt.config import Config
+from litgpt.scripts.convert_hf_checkpoint import qkv_reassemble
+
+
+class GPT(nn.Module):
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        assert config.padded_vocab_size is not None
+        self.config = config
+
+        self.lm_head = nn.Linear(config.n_embd, config.padded_vocab_size, bias=config.lm_head_bias)
+        self.transformer = nn.ModuleDict(
+            dict(
+                wte=nn.Embedding(config.padded_vocab_size, config.n_embd),
+                h=nn.ModuleList(Block(config, block_idx) for block_idx in range(config.n_layer)),
+                ln_f=config.norm_class(config.n_embd, eps=config.norm_eps),
+            )
+        )
+        self.mask_cache: Optional[torch.Tensor] = None
+        self.max_seq_length = self.config.block_size
+
+    @property
+    def max_seq_length(self) -> int:
+        return self._max_seq_length
+
+    @max_seq_length.setter
+    def max_seq_length(self, value: int) -> None:
+        """
+        When doing inference, the sequences used might be shorter than the model's context length.
+        This allows setting a smaller number to avoid allocating unused memory
+        """
+        if value > self.config.block_size:
+            raise ValueError(
+                f"Cannot attend to {value}, block size is only {self.config.block_size}."
+                " This is likely because the input text exceeds the supported context length of this model."
+            )
+        self._max_seq_length = value
+        if not hasattr(self, "cos"):
+            # first call
+            cos, sin = self.rope_cache()
+            self.register_buffer("cos", cos, persistent=False)
+            self.register_buffer("sin", sin, persistent=False)
+        # override
+        elif value != self.cos.size(0):
+            self.cos, self.sin = self.rope_cache(device=self.cos.device)
+        # the mask and kv cache size will get updated on `set_kv_cache`. we cannot update it here because we don't know
+        # if the kv cache is expected
+        if self.mask_cache is not None and self.mask_cache.shape[-1] < value:
+            print(
+                f"Warning: KV cache has length {self.mask_cache.shape[-1]} < {value} = max_seq_length. Call 'set_kv_cache' before doing any forwards!"
+            )
+
+    def reset_parameters(self) -> None:
+        # Trigger resetting the rope-cache
+        self.cos, self.sin = self.rope_cache(device=self.cos.device)
+
+    def _init_weights(self, module: nn.Module) -> None:
+        """Meant to be used with `gpt.apply(gpt._init_weights)`."""
+        if isinstance(module, nn.Linear):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                torch.nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    def forward(
+        self,
+        idx: torch.Tensor,
+        input_pos: Optional[torch.Tensor] = None,
+        input_pos_maxp1: Optional[int] = None,
+        lm_head_chunk_size: int = 0,
+    ) -> Union[torch.Tensor, List[torch.Tensor]]:
+        """
+        If `input_pos` is provided, the KV cache uses K and V vectors for
+        positions smaller than entries in `input_pos`. For efficiency, pass
+        `input_pos_maxp1` as `max(input_pos) + 1` if already available from
+        your forward algorithm. This slices the KV cache buffers and speeds
+        up multi-head attention.
+
+        Without `input_pos_maxp1`, the computation uses the full KV cache
+        (`max_seq_length`) with masking applied. Note that inferring
+        `input_pos_maxp1` from `input_pos` causes graph breaks and prevents
+        compilation.
+
+        Args:
+            idx: Token indices of input sequences, shape `(B, T)`, where `B`
+                is batch size.
+            input_pos: Optional. Positions of input tokens. The default is
+                `arange(T)`. Can have shape `(T,)` or `(B, T)` (batched index).
+            input_pos_maxp1: Optional. See above.
+            lm_head_chunk_size: Optional. If `lm_head_chunk_size > 0`, the final
+                `lm_head` computation is done in chunks of this size.
+
+        Returns:
+            Logit outputs, shape `(B, T, config.padded_vocab_size)`. If
+            `lm_head_chunk_size > 0`, this is a list of chunks of shape
+            `(B, lm_head_chunk_size, config.padded_vocab_size)`, the final
+            entry can be shorter.
+
+        """
+        T = idx.size(1)
+        if self.max_seq_length < T:
+            raise ValueError(f"Cannot forward sequence of length {T}, max seq length is only {self.max_seq_length}.")
+
+        if input_pos is not None:  # use the kv cache
+            if input_pos.dim() > 2:
+                # otherwise, things go wrong in `apply_rope`
+                raise ValueError(f"input_pos must have 1 or 2 dimensions, input_pos.shape = {input_pos.shape}")
+            if input_pos.shape[-1] != T:
+                raise ValueError(f"input_pos.shape[-1] = {input_pos.shape[-1]} != {T} = idx.shape[1], must be the same")
+            cos = batched_index_select(self.cos, 0, input_pos)
+            sin = batched_index_select(self.sin, 0, input_pos)
+            if input_pos.dim() == 1:
+                cos = cos.unsqueeze(0)
+                sin = sin.unsqueeze(0)
+            if self.mask_cache is None:
+                raise TypeError("You need to call `gpt.set_kv_cache()`")
+            mask = batched_index_select(self.mask_cache, 2, input_pos)
+            if mask.dim() > 4:
+                # the mask cache has a batch dim of 1 in addition to the one
+                # we get if input_pos has a batch dimension
+                mask = mask.view(*(mask.shape[0:1] + mask.shape[2:]))
+            if input_pos_maxp1 is not None:
+                # Shorten final dimension so it just covers all `input_pos` entries
+                if input_pos_maxp1 > self.max_seq_length:
+                    raise ValueError(f"Positions in 'input_pos' must be in [0,{self.max_seq_length})")
+                mask = mask[..., :input_pos_maxp1]
+        else:
+            # unsqueeze to have a batch dimension
+            cos = self.cos[:T].unsqueeze(0)
+            sin = self.sin[:T].unsqueeze(0)
+            # `cos`, `sin` have shape (1, T, config.rope_n_elem)
+            mask = None  # defaults to causal mask
+            input_pos_maxp1 = None
+
+        x = self.transformer.wte(idx)  # token embeddings of shape (B, T, n_embd)
+        if self.config.scale_embeddings:
+            x = x * torch.tensor(self.config.n_embd**0.5, dtype=x.dtype)
+
+        for block_idx, block in enumerate(self.transformer.h):
+            if self.config.rope_indices is not None:
+                x = block(
+                    x,
+                    cos[..., self.config.rope_indices[block_idx]],
+                    sin[..., self.config.rope_indices[block_idx]],
+                    mask,
+                    input_pos,
+                    input_pos_maxp1,
+                )
+            else:
+                x = block(x, cos, sin, mask, input_pos, input_pos_maxp1)
+        x = self.transformer.ln_f(x)
+        clamp_head = (
+            partial(do_softcapping, thresh=self.config.final_logit_softcapping)
+            if self.config.final_logit_softcapping is not None
+            else nn.Identity()
+        )
+        if lm_head_chunk_size > 0:
+            # chunk the lm head logits to reduce the peak memory used by autograd
+            return [clamp_head(self.lm_head(x_i)) for x_i in x.split(lm_head_chunk_size, dim=1)]
+        else:
+            return clamp_head(self.lm_head(x))  # (B, T, padded_vocab_size)
+
+    @classmethod
+    def from_name(cls, name: str, **kwargs: Any) -> Self:
+        return cls(Config.from_name(name, **kwargs))
+
+    def rope_cache(self, device: Optional[torch.device] = None) -> Tuple[torch.Tensor, torch.Tensor]:
+        if self.config.rope_adjustments is None:
+            extra_config = None
+
+        else:
+            adjusted_params_required = ["factor", "low_freq_factor", "high_freq_factor", "original_max_seq_len"]
+            params_present = [param in self.config.rope_adjustments for param in adjusted_params_required]
+            num_params_present = sum(params_present)
+
+            if num_params_present == 0:
+                extra_config = None  # uses standard RoPE
+            elif num_params_present == 4:
+                # These parameters should always be used together so that we don't interfere with standard rope
+                extra_config = {name: self.config.rope_adjustments[name] for name in adjusted_params_required}
+            elif "factor" in self.config.rope_adjustments:
+                # linear RoPE
+                adjusted_params_required = ["factor"]
+                extra_config = {name: self.config.rope_adjustments[name] for name in adjusted_params_required}
+            else:
+                # Some but not all parameters are specified; raise an error
+                missing_params = [
+                    param for param, present in zip(adjusted_params_required, params_present) if not present
+                ]
+                raise ValueError(
+                    f"The following adjusted RoPE parameters are missing in rope_adjustments: {', '.join(missing_params)}. "
+                    "All adjusted RoPE parameters must be specified together."
+                )
+
+        return build_rope_cache(
+            seq_len=self.max_seq_length,
+            n_elem=self.config.rope_n_elem,
+            device=device,
+            condense_ratio=self.config.rope_condense_ratio,
+            base=self.config.rope_base,
+            extra_config=extra_config,
+            rope_local_base_freq=self.config.rope_local_base_freq,
+        )
+
+    def set_kv_cache(
+        self,
+        batch_size: int,
+        max_seq_length: Optional[int] = None,
+        rope_cache_length: Optional[int] = None,
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ) -> None:
+        if rope_cache_length is None:
+            if len(self.cos.shape) == 2:
+                rope_cache_length = self.cos.size(-1)
+            else:
+                rope_cache_length = self.cos[..., 0].size(-1)
+
+        if max_seq_length is None:
+            max_seq_length = self.max_seq_length
+
+        # initialize the kv cache for all blocks
+        for block in self.transformer.h:
+            block.attn.kv_cache = block.attn.build_kv_cache(
+                batch_size,
+                max_seq_length,
+                rope_cache_length,
+                device,
+                dtype,
+            )
+
+        if self.mask_cache is None or self.mask_cache.size(3) != max_seq_length:
+            # passing `attn_mask` to SDPA disables the flash implementation. since we only need the mask
+            # for the kv-cache support (only during inference), we only create it in that situation
+            self.mask_cache = build_mask_cache(max_seq_length, device)
+
+    def clear_kv_cache(self) -> None:
+        self.mask_cache = None
+        for block in self.transformer.h:
+            block.attn.kv_cache = None
+
+
+class Block(nn.Module):
+    def __init__(
+        self,
+        config: Config,
+        block_idx: int,
+    ) -> None:
+        super().__init__()
+        if not config.parallel_residual and config.shared_attention_norm:
+            raise NotImplementedError(
+                "No checkpoint amongst the ones we support uses this configuration"
+                " (non-parallel residual and shared attention norm)."
+            )
+
+        self.norm_1 = nn.Identity() if not config.norm_1 else config.norm_class(config.n_embd, eps=config.norm_eps)
+        self.attn = CausalSelfAttention(config, block_idx)
+        self.post_attention_norm = (
+            config.norm_class(config.n_embd, eps=config.norm_eps) if config.post_attention_norm else nn.Identity()
+        )
+        self.norm_2 = (
+            nn.Identity()
+            if not config.norm_2
+            else (None if config.shared_attention_norm else config.norm_class(config.n_embd, eps=config.norm_eps))
+        )
+        self.mlp = config.mlp_class(config)
+        self.post_mlp_norm = (
+            config.norm_class(config.n_embd, eps=config.norm_eps) if config.post_mlp_norm else nn.Identity()
+        )
+
+        self.config = config
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        cos: torch.Tensor,
+        sin: torch.Tensor,
+        mask: Optional[torch.Tensor] = None,
+        input_pos: Optional[torch.Tensor] = None,
+        input_pos_maxp1: Optional[int] = None,
+    ) -> torch.Tensor:
+        """
+        Non-parallel residual       Parallel residual
+           ┌─ x                     ┌─ x ──────────────────┐             Note: if `shared_attention_norm` is True,
+           │  ↓                     │  ↓                   ↓                   the output from `norm_1` is reused
+           │  norm_1                │  norm_1  ───────►    norm_2
+           │  ↓                     │  ↓                   ↓
+           │  attn                  │  attn                MLP
+           │  ↓                     │  ↓                   ↓
+           |  post_attn_norm        |  post_attn_norm      post_mlp_norm
+           |  ↓                     |  ↓                   ↓
+        ┌─ └► +                     └► + ◄─────────────────┘
+        |     ↓
+        │     norm_2
+        │     ↓
+        │     MLP
+        │     ↓
+        |     post_mlp_norm
+        |     ↓
+        └───► +
+        """
+
+        x_normed = self.norm_1(x)
+        attention_output = self.attn(x_normed, cos, sin, mask, input_pos, input_pos_maxp1)
+        attention_output = self.post_attention_norm(attention_output)
+
+        if self.config.parallel_residual:
+            if not self.config.shared_attention_norm:
+                x_normed = self.norm_2(x)
+            x = attention_output + x
+        else:
+            x = attention_output + x
+            x_normed = self.norm_2(x)
+
+        return self.post_mlp_norm(self.mlp(x_normed)) + x
+
+
+class CausalSelfAttention(nn.Module):
+    def __init__(self, config: Config, block_idx: int) -> None:
+        super().__init__()
+        # key, query and value projections for all heads, but in a batch
+        self.qkv = nn.Linear(
+            config.n_embd,
+            (config.n_head + 2 * config.n_query_groups) * config.head_size,  # support for grouped/multi queries
+            bias=config.bias or config.attn_bias,
+        )
+        # output projection
+        self.proj = nn.Linear(config.head_size * config.n_head, config.n_embd, bias=config.bias)
+        # disabled by default
+        self.kv_cache: Optional[KVCache] = None
+        self.apply_sliding_window_attention = False
+        if config.sliding_window_size is not None and config.sliding_window_indices is not None:
+            self.apply_sliding_window_attention = config.sliding_window_indices[block_idx]
+
+        if config.norm_qk:
+            norm_q_size = config.n_head * config.head_size if config.norm_qk_type == "olmo2" else config.head_size
+            norm_k_size = (
+                config.n_query_groups * config.head_size if config.norm_qk_type == "olmo2" else config.head_size
+            )
+            self.norm_q = config.norm_class(norm_q_size, eps=config.norm_eps)
+            self.norm_k = config.norm_class(norm_k_size, eps=config.norm_eps)
+        else:
+            self.norm_q = self.norm_k = None
+
+        self.config = config
+        self.block_idx = block_idx
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        cos: torch.Tensor,
+        sin: torch.Tensor,
+        mask: Optional[torch.Tensor] = None,
+        input_pos: Optional[torch.Tensor] = None,
+        input_pos_maxp1: Optional[int] = None,
+    ) -> torch.Tensor:
+        # Notation:
+        # - B          | batch size
+        # - T          | time-step (sequence length)
+        # - C          | model's embeddings size (n_embd)
+        # - C*         | attentions's embeddings size
+        # - hs         | head size
+        # - nh_(q,k,v) | number of heads for query, key and value
+        # - n_query_groups = nh_k = nh_v | number of query groups sharing key and value heads
+        # alternative notation: num_kv_groups = n_query_groups
+        # ┌───┐┌───┐┌───┐┌───┐     ┌───┐    ┌───┐             ┌───┐
+        # │ v ││ v ││ v ││ v │     │ v │    │ v │             │ v │
+        # └───┘└───┘└───┘└───┘     └───┘    └───┘             └───┘
+        #   │    │    │    │         │        │                 │
+        # ┌───┐┌───┐┌───┐┌───┐     ┌───┐    ┌───┐             ┌───┐
+        # │ k ││ k ││ k ││ k │     │ k │    │ k │             │ k │
+        # └───┘└───┘└───┘└───┘     └───┘    └───┘             └───┘
+        #   │    │    │    │      ┌──┴──┐  ┌──┴──┐      ┌────┬──┴─┬────┐
+        # ┌───┐┌───┐┌───┐┌───┐  ┌───┐┌───┐┌───┐┌───┐  ┌───┐┌───┐┌───┐┌───┐
+        # │ q ││ q ││ q ││ q │  │ q ││ q ││ q ││ q │  │ q ││ q ││ q ││ q │
+        # └───┘└───┘└───┘└───┘  └───┘└───┘└───┘└───┘  └───┘└───┘└───┘└───┘
+        # ◀──────────────────▶  ◀──────────────────▶  ◀──────────────────▶
+        #         MHA                    GQA                   MQA
+        #   n_query_groups=4       n_query_groups=2      n_query_groups=1
+        #
+        # credit https://arxiv.org/pdf/2305.13245.pdf
+        head_size = self.config.head_size
+        n_head = self.config.n_head
+        n_query_groups = self.config.n_query_groups
+        rope_n_elem = self.config.rope_n_elem
+        B, T, C = x.size()  # batch size, sequence length, embedding dimensionality (n_embd)
+
+        # Perform a single multiplication operation using a combined QKV matrix to calculate `query`, `key`, and `value`
+        # instead of individually multiplying the input `x` with the respective weight matrices.
+        qkv = self.qkv(x)  # (B, T, 3xC*)
+
+        # Define query, key and value sizes.
+        # If grouped/multi query is enabled, these sizes are not equal (see the diagram above).
+        query_size = n_head * head_size
+        key_size = value_size = n_query_groups * head_size
+        # Split qkv into query, key and value matrices.
+        q, k, v = qkv.split((query_size, key_size, value_size), dim=-1)  # 3x(B, T, C*)
+
+        if self.config.norm_qk and self.config.norm_qk_type == "olmo2":
+            q = self.norm_q(q)
+            k = self.norm_k(k)
+
+        # To place the num_heads (nh) dimension right after the batch (B) dimension, the first step is to decouple the
+        # embedding size (C) into num_heads (nh) and head_size (hs).
+
+        # The original GQA paper is followed here and the term query groups is used.
+        # alternative notation: Query groups are also referred to as KV groups.
+        q = q.view(B, T, n_head, head_size)  # (B, T, nh_q, hs)
+        k = k.view(B, T, n_query_groups, head_size)  # (B, T, n_query_groups, hs)
+        v = v.view(B, T, n_query_groups, head_size)  # (B, T, n_query_groups, hs)
+
+        # The tensors `query`, `key`, and `value` are now accurately structured: within each batch element (B), there are
+        # multiple heads (nh), and within each head, there is a sequence of elements (T), each represented by a vector
+        # of size `hs`.
+        q = q.transpose(1, 2)  # (B, nh_q, T, hs)
+        k = k.transpose(1, 2)  # (B, nh_k, T, hs)
+        v = v.transpose(1, 2)  # (B, nh_v, T, hs)
+
+        if self.config.norm_qk and self.config.norm_qk_type == "default":
+            q = self.norm_q(q)
+            k = self.norm_k(k)
+
+        # Unlike standard positional embeddings rotary embeddings must be applied at every layer.
+        q_roped = apply_rope(q[..., :rope_n_elem], cos, sin)
+        k_roped = apply_rope(k[..., :rope_n_elem], cos, sin)
+        q = torch.cat((q_roped, q[..., rope_n_elem:]), dim=-1)  # (B, nh_q, T, hs)
+        k = torch.cat((k_roped, k[..., rope_n_elem:]), dim=-1)  # (B, nh_k, T, hs)
+
+        # Apply kv-cache during inference.
+        if input_pos is not None:
+            if not isinstance(self.kv_cache, KVCache):
+                raise TypeError("You need to call `gpt.set_kv_cache()`")
+            k, v = self.kv_cache(input_pos, k, v)
+            if input_pos_maxp1 is not None:
+                # Subselect along sequence dimension
+                k = k[..., :input_pos_maxp1, :]
+                v = v[..., :input_pos_maxp1, :]
+            # k, v: (B, nh_k, input_pos_maxp1, hs)
+            # If input_pos_maxp1 is None -> max_seq_length
+
+        # Grouped queries: balance the number of heads across all three matrices.
+        # NOTE: flash attention requires it in training mode.
+        # Multi-query: this step can be skipped since there is only 1 head, allowing us to use broadcasting.
+        if n_query_groups != n_head and (input_pos is None or n_query_groups != 1):
+            q_per_kv = n_head // n_query_groups
+            k = k.repeat_interleave(q_per_kv, dim=1)  # (B, nh_q, T, hs)
+            v = v.repeat_interleave(q_per_kv, dim=1)  # (B, nh_q, T, hs)
+
+        if self.apply_sliding_window_attention:
+            """
+                  Global Window              Sliding window             Sliding window
+                  attention mask      +            bias          =      attention mask
+            ┌────────────────────────┐  ┌───────────────────────┐  ┌─────────────────────────┐
+            │ True False False False │  │ True  True  True True │  │ True  False False False │
+            │ True True  False False │  │ True  True  True True │  │ True  True  False False │
+            │ True True  True  False │  │ False True  True True │  │ False True  True  False │
+            │ True True  True  True  │  │ False False True True │  │ False False True  True  │
+            └────────────────────────┘  └───────────────────────┘  └─────────────────────────┘
+            """
+            if mask is None:
+                mask = torch.ones(T, T, dtype=q.dtype, device=q.device).triu(diagonal=1)
+                mask.masked_fill_(mask.bool(), float("-inf"))
+                mask = mask.view(1, 1, *mask.shape)
+            sliding_window_bias = torch.ones_like(mask).tril(diagonal=-self.config.sliding_window_size)
+            sliding_window_bias.masked_fill_(sliding_window_bias.bool(), float("-inf"))
+            mask += sliding_window_bias
+
+        # Efficient attention using Flash Attention CUDA kernels.
+        # NOTE: efficient implementation is disabled if `mask` is not None or softcapping is enabled.
+        # ↓ (B, nh, T, hs) @ (B, nh, T, hs).mT --> (B, nh, T, T) @ (B, nh, T, hs) --> (B, nh, T, hs)
+        y = self.scaled_dot_product_attention(q, k, v, mask)
+
+        # Re-assemble all head outputs side by side.
+        y = y.reshape(B, T, head_size * n_head)
+
+        # Output projection.
+        return self.proj(y)  # (B, T, C)
+
+    def scaled_dot_product_attention(
+        self, q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, mask: Optional[torch.Tensor] = None
+    ) -> torch.Tensor:
+        scale = 1.0 / math.sqrt(self.config.attention_scores_scalar or self.config.head_size)
+
+        # with softcapping we cannot use SDPA
+        if self.config.attention_logit_softcapping is not None:
+            scores = q @ k.mT * scale
+            scores = do_softcapping(scores, self.config.attention_logit_softcapping)
+            if mask is None:
+                mask = torch.ones(q.size(2), q.size(2), dtype=q.dtype, device=q.device).triu(diagonal=1)
+                mask.masked_fill_(mask.bool(), torch.finfo(q.dtype).min)
+            scores = scores + mask
+            scores = F.softmax(scores, dim=-1, dtype=torch.float).to(dtype=q.dtype)
+            y = scores @ v
+        else:
+            y = F.scaled_dot_product_attention(
+                q, k, v, attn_mask=mask, dropout_p=0.0, scale=scale, is_causal=mask is None
+            )
+        return y.transpose(1, 2)
+
+    def build_kv_cache(
+        self,
+        batch_size: int,
+        max_seq_length: int,
+        rope_cache_length: Optional[int] = None,
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ) -> "KVCache":
+        v_shape = (batch_size, self.config.n_query_groups, max_seq_length, self.config.head_size)
+        if rope_cache_length is None:
+            if self.config.rotary_percentage != 1.0:
+                raise TypeError("Please pass the `rope_cache_length=gpt.cos.size(-1)` value")
+            k_shape = v_shape
+        else:
+            k_shape = (
+                batch_size,
+                self.config.n_query_groups,
+                max_seq_length,
+                rope_cache_length + self.config.head_size - self.config.rope_n_elem,
+            )
+        return KVCache(k_shape, v_shape, device=device, dtype=dtype)
+
+    def _load_from_state_dict(self, state_dict: dict, prefix: str, *args: Any, **kwargs: Any) -> None:
+        """For compatibility with legacy checkpoints."""
+
+        for attr in ("weight", "bias"):
+            legacy_key = f"{prefix}attn.{attr}"
+            current_key = f"{prefix}qkv.{attr}"
+            if legacy_key in state_dict:
+                state_dict[current_key] = qkv_reassemble(state_dict.pop(legacy_key), self.config)
+
+        super()._load_from_state_dict(state_dict, prefix, *args, **kwargs)
+
+
+class GptNeoxMLP(nn.Module):
+    def __init__(self, config: Config, intermediate_size: Optional[int] = None) -> None:
+        super().__init__()
+        self.intermediate_size = intermediate_size or config.intermediate_size
+        self.fc = nn.Linear(config.n_embd, self.intermediate_size, bias=config.bias)
+        self.proj = nn.Linear(self.intermediate_size, config.n_embd, bias=config.bias)
+        self.config = config
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.fc(x)
+        x = F.gelu(x, approximate=self.config.gelu_approximate)
+        return self.proj(x)
+
+
+class LLaMAMLP(nn.Module):
+    def __init__(self, config: Config, intermediate_size: Optional[int] = None) -> None:
+        super().__init__()
+        self.intermediate_size = intermediate_size or config.intermediate_size
+        self.fc_1 = nn.Linear(config.n_embd, self.intermediate_size, bias=config.bias)
+        self.fc_2 = nn.Linear(config.n_embd, self.intermediate_size, bias=config.bias)
+        self.proj = nn.Linear(self.intermediate_size, config.n_embd, bias=config.bias)
+        self.config = config
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x_fc_1 = self.fc_1(x)
+        x_fc_2 = self.fc_2(x)
+        x = F.silu(x_fc_1) * x_fc_2
+        return self.proj(x)
+
+
+class GemmaMLP(LLaMAMLP):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x_fc_1 = self.fc_1(x)
+        x_fc_2 = self.fc_2(x)
+        x = F.gelu(x_fc_1, approximate=self.config.gelu_approximate) * x_fc_2
+        return self.proj(x)
+
+
+class LLaMAMoE(nn.Module):
+    def __init__(self, config: Config) -> None:
+        super().__init__()
+        self.gate = nn.Linear(config.n_embd, config.n_expert, bias=False)
+        self.experts = nn.ModuleList(
+            LLaMAMLP(config, intermediate_size=config.moe_intermediate_size) for _ in range(config.n_expert)
+        )
+        self.config = config
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Derived from: https://github.com/mistralai/mistral-src/blob/b46d6/moe_one_file_ref.py#L203-L219
+        See also figure 1 in https://arxiv.org/abs/2211.15841
+        """
+        B, T, C = x.size()  # batch size, sequence length, embedding dimensionality (n_embd)
+        x = x.view(-1, C)  # (B*T, C)
+        router = self.gate(x)  # (B*T, n_expert)
+        probs, indices = torch.topk(router, self.config.n_expert_per_token)  # (B*T, n_expert_per_token)
+        probs = probs.softmax(dim=1, dtype=torch.float).to(dtype=x.dtype)
+        masks = indices.unsqueeze(-1) == torch.arange(self.config.n_expert, device=x.device)
+        masks = masks.permute(2, 0, 1)  # (n_expert, B*T, n_expert_per_token)
+        y = torch.zeros_like(x)  # (B*T, C)
+        for mask, expert in zip(masks, self.experts):
+            token_idx, expert_idx = torch.where(mask)
+            y[token_idx] += probs[token_idx, expert_idx, None] * expert(x[token_idx])
+        return y.view(B, T, C)
+
+
+def build_rope_cache(
+    seq_len: int,
+    n_elem: int,
+    device: Optional[torch.device] = None,
+    base: int = 10000,
+    condense_ratio: int = 1,
+    extra_config: Optional[dict] = None,
+    rope_local_base_freq: Optional[float] = None,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Enhanced Transformer with Rotary Position Embedding.
+
+    Args:
+        seq_len (int): Sequence length.
+        n_elem (int): Number of elements (head dimension).
+        device (torch.device, optional): Device for tensor allocations.
+        base (int, optional): Base for computing inverse frequencies.
+        condense_ratio (int, optional): Ratio to condense the position indices.
+        extra_config (dict, optional): Configuration parameters for frequency adjustments (used by Llama 3.1 and 3.2)
+
+    Returns:
+        Tuple[torch.Tensor, torch.Tensor]: Cosine and sine caches for RoPE.
+            Shapes are `(seq_len, n_elem)`.
+    """
+
+    # Compute the inverse frequencies theta
+    theta = 1.0 / (base ** (torch.arange(0, n_elem, 2, device=device).float() / n_elem))
+
+    if extra_config is not None:
+        factor = extra_config["factor"]
+        if "original_max_seq_len" in extra_config:
+            orig_context_len = extra_config["original_max_seq_len"]
+            low_freq_factor = extra_config["low_freq_factor"]
+            high_freq_factor = extra_config["high_freq_factor"]
+
+            wavelen = 2 * torch.pi / theta
+            ratio = orig_context_len / wavelen
+            smooth_factor = (ratio - low_freq_factor) / (high_freq_factor - low_freq_factor)
+            smooth_factor = torch.clamp(smooth_factor, min=0.0, max=1.0)
+
+            # Compute adjusted_theta without masked indexing
+            adjusted_theta = (1 - smooth_factor) * (theta / factor) + smooth_factor * theta
+            theta = adjusted_theta
+        else:
+            theta = theta / factor
+
+    # Create position indices `[0, 1, ..., seq_len - 1]`
+    seq_idx = torch.arange(seq_len, device=device) / condense_ratio
+
+    # Calculate the product of position index and $\theta_i$
+    idx_theta = torch.outer(seq_idx, theta).repeat(1, 2)
+    # If `n_elem` is odd, the final dimension of `idx_theta` has size
+    # `n_elem + 1`, so need to cut something off.
+    # Due to a current bug in Hugging Face, in the case `n_elem == 1`, we leave
+    # `idx_theta`, `cos`, `sin` as is. Things work out in `apply_rope` due to
+    # broadcasting. If we shorten `idx_theta`, unit tests comparing to
+    # Hugging Face fail.
+    # https://github.com/huggingface/transformers/issues/35233
+    if idx_theta.shape[-1] > n_elem > 1:
+        idx_theta = idx_theta[..., :n_elem]
+
+    # if rope_local_base_freq is given, have a separate rope value for local embedding
+    # For now, we use default RoPE for local embedding
+    if rope_local_base_freq is not None:
+        local_theta = 1.0 / (rope_local_base_freq ** (torch.arange(0, n_elem, 2, device=device).float() / n_elem))
+        local_idx_theta = torch.outer(seq_idx, local_theta)
+        local_idx_theta = local_idx_theta.repeat(1, 2)
+        if local_idx_theta.shape[-1] > n_elem > 1:
+            local_idx_theta = local_idx_theta[..., :n_elem]
+
+        idx_theta = torch.stack((idx_theta, local_idx_theta), dim=-1)
+
+    return torch.cos(idx_theta), torch.sin(idx_theta)
+
+
+def batched_index_select(t, dim, idx):
+    """index_select for batched index and unbatched t"""
+    if idx.dim() == 1:
+        return torch.index_select(t, dim, idx)
+
+    *batch_shape, idx_size = idx.shape
+    res = torch.index_select(t, dim, idx.reshape(-1))  # flat index
+    # split out single batch idx
+    res = res.view(*t.shape[:dim], -1, idx_size, *t.shape[dim + 1 :])
+    if dim > 0:
+        # move batch dim to front, this is np.rollaxis(res, dim, 0) for tensors
+        dims = [dim] + list(range(res.dim()))
+        del dims[dim + 1]
+        res = res.permute(dims)
+    # unflatten batch dims
+    res = res.view(*batch_shape, *res.shape[1:])
+    return res
+
+
+def batched_index_copy_(t, dim, idx, val):
+    """Index copy for batched t, idx, val"""
+
+    if t.device.type == "mps":
+        # Normalize negative dimensions
+        if dim < 0:
+            dim = t.dim() + dim
+        if idx.dim() == 1:
+            idx_shape = [1] * val.dim()
+            idx_shape[dim] = -1
+            idx_expanded = idx.view(*idx_shape)
+            idx_expanded = idx_expanded.expand_as(val)
+            t.scatter_(dim, idx_expanded, val)
+            return t
+
+        elif idx.dim() == 2:
+            assert dim != 0, "Cannot index the batch dimension"
+            batch_size = idx.size(0)
+            idx_size = idx.size(1)
+            assert batch_size == t.size(0) == val.size(0)
+
+            idx_shape = [batch_size] + [1] * (val.dim() - 1)
+            idx_shape[dim] = idx_size
+            idx_expanded = idx.view(*idx_shape)
+            idx_expanded = idx_expanded.expand_as(val)
+
+            t.scatter_(dim, idx_expanded, val)
+            return t
+        else:
+            raise NotImplementedError(f"idx.dim() == {idx.dim()} not supported")
+
+    else:
+        if idx.dim() == 1:
+            return t.index_copy_(dim, idx, val)
+
+        assert idx.dim() == 2, f"multiple batch dims not yet {idx.shape=}"
+        assert dim != 0, f"cannot index batch dim {dim=}"
+        batch_size, idx_size = idx.shape
+        assert batch_size == t.size(0)
+        assert batch_size == val.size(0)
+
+        # if we can view the batch and indexed dimensions together, we could
+        # do index trickery. This is, sadly, not the case for kvcache so we
+        # fall back to for loop
+        for i in range(batch_size):
+            unbatched_dim = dim if dim < 0 else dim - 1
+            t[i].index_copy_(unbatched_dim, idx[i], val[i])
+        return t
+
+
+def apply_rope(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
+    """
+    Applies RoPE transform to `x`. Note that `cos`, `sin` need to have a batch
+    dimension.
+
+    Args:
+        x: Input tensor, `(B, ..., T, head_size)`
+        cos: Cached cosines, `(B, T, head_size)` or `(1, T, head_size)`
+        sin: Cached sines, `(B, T, head_size)` or `(1, T, head_size)`
+
+    Returns:
+        Encoded tensor, `(B, ..., T, head_size)`
+    """
+    if cos.dim() != 3:
+        raise ValueError(f"cos must be three-dimensional, but shape is {cos.shape}")
+    if cos.shape != sin.shape:
+        raise ValueError(f"cos, sin must have same shape, but cos.shape={cos.shape}, sin.shape={sin.shape}")
+    head_size_half = x.size(-1) // 2
+    x1 = x[..., :head_size_half]  # (B, ..., T, head_size/2)
+    x2 = x[..., head_size_half:]  # (B, ..., T, head_size/2)
+    rotated = torch.cat((-x2, x1), dim=-1)  # (B, ..., T, head_size)
+    dims_diff = x.dim() - cos.dim()
+    if dims_diff > 0:
+        # Ensure that shapes of `x`, `cos`, `sin` align
+        new_shape = cos.shape[0:1] + (1,) * dims_diff + cos.shape[1:]
+        cos = cos.view(*new_shape)
+        sin = sin.view(*new_shape)
+
+    roped = (x * cos) + (rotated * sin)
+    return roped.to(dtype=x.dtype)
+
+
+def do_softcapping(x: torch.Tensor, thresh: float) -> torch.Tensor:
+    return torch.tanh(x / thresh) * thresh
+
+
+class KVCache(nn.Module):
+    """
+    Buffers `k`, `v` have shape
+    `(batch_size, n_query_groups, max_seq_length, head_size)`.
+    """
+
+    def __init__(
+        self,
+        k_shape: Tuple[int, int, int, int],
+        v_shape: Tuple[int, int, int, int],
+        device: Optional[torch.device] = None,
+        dtype: Optional[torch.dtype] = None,
+    ) -> None:
+        super().__init__()
+        self.register_buffer("k", torch.zeros(k_shape, device=device, dtype=dtype), persistent=False)
+        self.register_buffer("v", torch.zeros(v_shape, device=device, dtype=dtype), persistent=False)
+
+    def forward(self, input_pos: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        Writes new values `k` and `v` into the cache at the positions specified
+        by `input_pos` along the sequence dimension (`max_seq_length`). The batch
+        size of `k` and `v` (`bs`) must be smaller or equal to `KVCache` batch
+        size. Returns the full buffers, adjusted to the batch size `bs`.
+
+        Args:
+            input_pos: Position index, `(bs, T)` or `(T,)`
+            k: New values, `(bs, n_query_groups, T, head_size)`
+            v: New values, `(bs, n_query_groups, T, head_size)`
+
+        Returns:
+            k_full, v_full, `(bs, n_query_groups, max_seq_length, head_size)`
+
+        """
+        # move the buffer to the activation dtype for when AMP is used
+        if self.k.dtype != k.dtype:
+            self.k = self.k.to(k.dtype)
+        if self.v.dtype != v.dtype:
+            self.v = self.v.to(v.dtype)
+        # update the cache
+        bs = k.size(0)
+        k = batched_index_copy_(self.k[:bs, ...], -2, input_pos, k)
+        v = batched_index_copy_(self.v[:bs, ...], -2, input_pos, v)
+        return k, v
+
+    def reset_parameters(self) -> None:
+        torch.nn.init.zeros_(self.k)
+        torch.nn.init.zeros_(self.v)
+
+
+def build_mask_cache(max_seq_length: int, device: Optional[torch.device] = None) -> torch.Tensor:
+    ones = torch.ones((max_seq_length, max_seq_length), device=device, dtype=torch.bool)
+    return torch.tril(ones).unsqueeze(0).unsqueeze(0)
+
+
+class RMSNorm(torch.nn.Module):
+    """Root Mean Square Layer Normalization.
+
+    Derived from https://github.com/bzhangGo/rmsnorm/blob/master/rmsnorm_torch.py. BSD 3-Clause License:
+    https://github.com/bzhangGo/rmsnorm/blob/master/LICENSE.
+    """
+
+    def __init__(self, size: int, dim: int = -1, eps: float = 1e-6, add_unit_offset: bool = False) -> None:
+        super().__init__()
+        self.weight = torch.nn.Parameter(torch.ones(size))
+        self.eps = eps
+        self.dim = dim
+        self.add_unit_offset = add_unit_offset
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        dtype = x.dtype
+        x = x.float()
+        # NOTE: the original RMSNorm paper implementation is not equivalent
+        norm_x = torch.mean(x * x, dim=self.dim, keepdim=True)
+        x_normed = x * torch.rsqrt(norm_x + self.eps)
+        weight = (1 + self.weight) if self.add_unit_offset else self.weight
+        return (x_normed * weight.float()).to(dtype=dtype)
+
+    def reset_parameters(self) -> None:
+        torch.nn.init.ones_(self.weight)

litgpt/perplexity.py

@@ -0,0 +1,513 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import math
+import pprint
+import time
+import os
+import json
+from dataclasses import asdict
+from datetime import timedelta
+from functools import partial
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+
+import lightning as L
+import torch
+import torch.nn as nn
+from lightning.fabric.strategies import FSDPStrategy
+from lightning.fabric.utilities.throughput import ThroughputMonitor, measure_flops
+from torch.utils.data import DataLoader
+from torchmetrics.aggregation import RunningMean
+from typing_extensions import Literal
+
+from litgpt import Tokenizer
+from litgpt.args import EvalArgs, LogArgs, TrainArgs
+from litgpt.config import name_to_config
+from litgpt.data import DataModule, TinyLlama, Arxiv
+from litgpt.model import GPT, Block, CausalSelfAttention, Config, LLaMAMLP
+from litgpt.utils import (
+    CycleIterator,
+    capture_hparams,
+    check_nvlink_connectivity,
+    choose_logger,
+    chunked_cross_entropy,
+    copy_config_files,
+    extend_checkpoint_dir,
+    find_resume_path,
+    get_default_supported_precision,
+    init_out_dir,
+    instantiate_torch_optimizer,
+    num_parameters,
+    parse_devices,
+    reset_parameters,
+    save_config,
+    save_hyperparameters,
+)
+
+
+def setup(
+    model_name: str,
+    model_config: Optional[Config] = None,
+    out_dir: Path = Path("out/pretrain"),
+    precision: Literal["bf16-true", "bf16-mixed", "32-true", None] = None,
+    initial_checkpoint_dir: Optional[Path] = None,
+    resume: Union[bool, Literal["auto"], Path] = False,
+    data: Optional[DataModule] = None,
+    data_dir: Path = None,
+    train: TrainArgs = TrainArgs(
+        save_interval=1000,
+        log_interval=1,
+        global_batch_size=512,
+        micro_batch_size=4,
+        max_tokens=int(3e12),  # 3 trillion
+        max_norm=1.0,
+        min_lr=4e-5,
+        lr_warmup_steps=2000,
+        tie_embeddings=False,
+    ),
+    eval: EvalArgs = EvalArgs(interval=1000, max_iters=100),
+    log: LogArgs = LogArgs(),
+    optimizer: Union[str, Dict] = "AdamW",
+    devices: Union[int, str] = "auto",
+    num_nodes: int = 1,
+    tokenizer_dir: Optional[Path] = None,
+    logger_name: Literal["wandb", "tensorboard", "csv", "mlflow"] = "tensorboard",
+    seed: int = 42,
+    multi_month: bool = False,
+):
+    """Pretrain a model.
+
+    Arguments:
+        model_name: The name of the model to pretrain. Choose from names in ``litgpt.config``. Use "list" to list the supported models.
+        model_config: A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+            ``model_config``. Overrides the `model_name` if specified.
+        out_dir: Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+            /teamspace/jobs/<job-name>/share.
+        precision: The precision to use for finetuning. Determines a compatible precision setting by default.
+        initial_checkpoint_dir: Optional path to a checkpoint directory to initialize the model from.
+            Useful for continued pretraining. Mutually exclusive with ``resume``.
+        resume: Path to a checkpoint directory to resume from in case training was interrupted, or ``True`` to resume
+            from the latest checkpoint in ``out_dir``. An error will be raised if no checkpoint is found. Passing
+            ``'auto'`` will resume from the latest checkpoint but not error if no checkpoint exists.
+        data: Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+        train: Training-related arguments. See ``litgpt.args.TrainArgs`` for details.
+        eval: Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details.
+        optimizer: An optimizer name (such as "AdamW") or config.
+
+        devices: How many devices/GPUs to use. Uses all GPUs by default.
+        num_nodes: How many nodes the code is being run on.
+        tokenizer_dir: Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+            module require this.
+        logger_name: The name of the logger to send metrics to.
+        seed: The random seed to use for reproducibility.
+    """
+    if model_name == "list":
+        available_models = "\n".join(sorted(name_to_config))
+        print(f"Available values:\n{available_models}")
+        quit()
+
+    if initial_checkpoint_dir is not None:
+        initial_checkpoint_dir = extend_checkpoint_dir(initial_checkpoint_dir)
+
+    if tokenizer_dir is not None:
+        tokenizer_dir = extend_checkpoint_dir(tokenizer_dir)
+
+    if model_config is None:
+        # Support both model_name options: meta-llama/Meta-Llama-3-8B & Meta-Llama-3-8B
+        try:
+            model_config = Config.from_name(model_name)
+        except ValueError:
+            print(f"Model name {model_name} is not supported.\n")
+            available_models = "\n".join(sorted(name_to_config))
+            print(f"Available values:\n{available_models}")
+            quit()
+
+    hparams = capture_hparams()
+
+    config = Config.from_name(model_name) if model_config is None else model_config
+    precision = precision or get_default_supported_precision(training=True)
+    devices = parse_devices(devices)
+    out_dir = init_out_dir(out_dir)
+    # in case the dataset requires the Tokenizer
+    tokenizer = Tokenizer(tokenizer_dir) if tokenizer_dir is not None else None
+
+    logger = choose_logger(
+        logger_name,
+        out_dir,
+        name=f"pretrain-{config.name}",
+        resume=bool(resume),
+        log_interval=train.log_interval,
+        log_args=asdict(log),
+    )
+
+    if devices * num_nodes > 1:
+        strategy = FSDPStrategy(auto_wrap_policy={Block}, state_dict_type="full", sharding_strategy="HYBRID_SHARD")
+    else:
+        strategy = "auto"
+
+    fabric = L.Fabric(devices=devices, num_nodes=num_nodes, strategy=strategy, precision=precision, loggers=[logger])
+
+    if torch.cuda.is_available() and devices > 1:
+        check_nvlink_connectivity(fabric)
+
+    fabric.launch()
+
+    fabric.print(pprint.pformat(hparams))
+    if logger_name in ("tensorboard", "wandb", "mlflow"):
+        fabric.logger.log_hyperparams(hparams)
+
+    main(
+        fabric=fabric,
+        devices=devices,
+        seed=seed,
+        initial_checkpoint_dir=initial_checkpoint_dir,
+        resume=resume,
+        config=config,
+        data=data,
+        data_dir=data_dir,
+        out_dir=out_dir,
+        tokenizer=tokenizer,
+        train=train,
+        eval=eval,
+        optimizer=optimizer,
+        multi_month=multi_month,
+    )
+
+
+def main(
+    fabric: L.Fabric,
+    devices: int,
+    seed: int,
+    initial_checkpoint_dir: Optional[Path],
+    resume: Union[bool, Literal["auto"], Path],
+    config: Config,
+    data: DataModule,
+    data_dir: Path,
+    out_dir: Path,
+    tokenizer: Optional[Tokenizer],
+    train: TrainArgs,
+    eval: EvalArgs,
+    optimizer: Union[str, Dict],
+    multi_month: bool = False,
+) -> None:
+    validate_args(train, eval, initial_checkpoint_dir, resume)
+
+    if fabric.global_rank == 0:
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+    fabric.seed_everything(seed)  # same seed for every process to init model (FSDP)
+
+    t0 = time.perf_counter()
+    with fabric.init_module(empty_init=True):
+        model = GPT(config)
+
+    initialize_weights(fabric, model, n_layer=config.n_layer, n_embd=config.n_embd)
+
+    if train.tie_embeddings:
+        model.transformer.wte.weight = model.lm_head.weight
+    if train.max_seq_length:
+        model.max_seq_length = train.max_seq_length
+
+    fabric.print(f"Time to instantiate model: {time.perf_counter() - t0:.02f} seconds.")
+    fabric.print(f"Total parameters: {num_parameters(model):,}")
+
+    model = torch.compile(model)
+    model = fabric.setup(model)
+
+    extra_kwargs = {"fused": fabric.device.type == "cuda"}
+    optimizer = instantiate_torch_optimizer(optimizer, model.parameters(), **extra_kwargs)
+    optimizer = fabric.setup_optimizers(optimizer)
+
+    if initial_checkpoint_dir:
+        ckpt_path = initial_checkpoint_dir / "lit_model.pth"
+
+        if fabric.global_rank == 0:
+            try:
+                obj = torch.load(ckpt_path, map_location="cpu")
+            except Exception as e:
+                raise RuntimeError(f"[load] Unable to read {ckpt_path}: {e}")
+
+            if isinstance(obj, dict) and "model" in obj:
+                import os
+                print(f"[fix] {ckpt_path} the full state, extract 'model' and write bacl", flush=True)
+                sd = obj["model"]
+                if len(sd) and next(iter(sd)).startswith("module."):
+                    sd = {k[7:]: v for k, v in sd.items()}
+
+                tmp = ckpt_path.with_suffix(".pth.tmp")
+                torch.save(sd, tmp)
+                os.replace(tmp, ckpt_path)
+                try:
+                    os.sync()
+                except Exception:
+                    pass
+                print(f"[fix] rewrite to make it 'model' only: {ckpt_path}", flush=True)
+            else:
+                print(f"[ok] {ckpt_path} already 'model' only", flush=True)
+
+        fabric.barrier()
+
+        fabric.load_raw(ckpt_path, model, strict=False)
+
+    from litgpt.data import Arxiv
+
+    if not multi_month:
+        if isinstance(data, Arxiv):
+            data.arxiv_train = str(data_dir).rstrip("/") + "/train"
+            data.arxiv_val = str(data_dir).rstrip("/") + "/train"
+        else:
+            NotImplementedError()
+        train_dataloader, val_dataloader = get_dataloaders(fabric, data, tokenizer, train, model.max_seq_length)
+        train_dataloader, val_dataloader = fabric.setup_dataloaders(train_dataloader, val_dataloader)
+
+        state = {
+            "model": model,
+            "optimizer": optimizer,
+            "train_dataloader": train_dataloader,
+            "iter_num": 0,
+            "step_count": 0,
+        }
+
+        resume = find_resume_path(resume, out_dir)
+        if resume:
+            fabric.print(f"Resuming training from {resume}")
+            fabric.load(resume, state)
+
+        train_time = time.perf_counter()
+
+        # work around PyTorch issue https://github.com/pytorch/pytorch/issues/152162
+        # which does not like the lazy initialization to be called in dynamo.
+        # Happens with PyTorch 2.7.
+        if (
+            torch.__version__.startswith("2.7.")
+            and (model._forward_module.__class__.__name__ == "OptimizedModule")
+            and (model._forward_module._orig_mod.__class__.__name__ == "FullyShardedDataParallel")
+        ):
+            from torch.distributed.fsdp._runtime_utils import _root_pre_forward
+
+            _root_pre_forward(model._forward_module._orig_mod, model._forward_module._orig_mod, [], {})
+
+        ppl(
+            fabric=fabric,
+            state=state,
+            val_dataloader=val_dataloader,
+            out_dir=out_dir,
+            train=train,
+            eval=eval,
+        )
+
+
+        total_tokens = state["iter_num"] * train.micro_batch_size * model.max_seq_length * fabric.world_size
+
+        # Print formatted output
+        separator = "-" * 40
+        fabric.print(separator)
+        fabric.print("| Performance")
+        fabric.print(f"| - Total tokens  : {total_tokens:,}")
+        fabric.print(f"| - Training Time : {(time.perf_counter() - train_time):.2f} s")
+        fabric.print(f"| - Tok/sec       : {total_tokens / train_time:.2f} tok/s")
+        fabric.print("| " + "-" * 40)
+
+        if fabric.device.type == "cuda":
+            memory_used = torch.cuda.max_memory_allocated() / 1e9
+            fabric.print("| Memory Usage")
+            fabric.print(f"| - Memory Used   : {memory_used:.2f} GB")
+        fabric.print(separator)
+
+    else:
+        months = [
+            "2407", "2408", "2409", "2410", "2411", "2412",
+            "2501", "2502", "2503", "2504", "2505", "2506"
+        ]
+        for month in months:
+            if isinstance(data, Arxiv):
+                data.arxiv_train = str(data_dir).rstrip("/") + f"/{month}/train"
+                data.arxiv_val = str(data_dir).rstrip("/") + f"/{month}/train"
+            else:
+                NotImplementedError()
+            train_dataloader, val_dataloader = get_dataloaders(fabric, data, tokenizer, train, model.max_seq_length)
+            train_dataloader, val_dataloader = fabric.setup_dataloaders(train_dataloader, val_dataloader)
+
+            state = {
+                "model": model,
+                "optimizer": optimizer,
+                "train_dataloader": train_dataloader,
+                "iter_num": 0,
+                "step_count": 0,
+            }
+
+            resume = find_resume_path(resume, out_dir)
+            if resume:
+                fabric.print(f"Resuming training from {resume}")
+                fabric.load(resume, state)
+
+            train_time = time.perf_counter()
+
+            # work around PyTorch issue https://github.com/pytorch/pytorch/issues/152162
+            # which does not like the lazy initialization to be called in dynamo.
+            # Happens with PyTorch 2.7.
+            if (
+                    torch.__version__.startswith("2.7.")
+                    and (model._forward_module.__class__.__name__ == "OptimizedModule")
+                    and (model._forward_module._orig_mod.__class__.__name__ == "FullyShardedDataParallel")
+            ):
+                from torch.distributed.fsdp._runtime_utils import _root_pre_forward
+
+                _root_pre_forward(model._forward_module._orig_mod, model._forward_module._orig_mod, [], {})
+
+            ppl(
+                fabric=fabric,
+                state=state,
+                val_dataloader=val_dataloader,
+                out_dir=out_dir/month,
+                train=train,
+                eval=eval,
+                month=month,
+            )
+
+            total_tokens = state["iter_num"] * train.micro_batch_size * model.max_seq_length * fabric.world_size
+
+            # Print formatted output
+            separator = "-" * 40
+            fabric.print(separator)
+            fabric.print("| Performance")
+            fabric.print(f"| - Total tokens  : {total_tokens:,}")
+            fabric.print(f"| - Training Time : {(time.perf_counter() - train_time):.2f} s")
+            fabric.print(f"| - Tok/sec       : {total_tokens / train_time:.2f} tok/s")
+            fabric.print("| " + "-" * 40)
+
+            if fabric.device.type == "cuda":
+                memory_used = torch.cuda.max_memory_allocated() / 1e9
+                fabric.print("| Memory Usage")
+                fabric.print(f"| - Memory Used   : {memory_used:.2f} GB")
+            fabric.print(separator)
+
+
+def ppl(
+    fabric: L.Fabric,
+    state: dict,
+    val_dataloader: DataLoader,
+    out_dir: Path,
+    train: TrainArgs,
+    eval: EvalArgs,
+    month: Optional[str] = None,
+) -> None:
+    model = state["model"]
+
+    with torch.device("meta"):
+        meta_model = GPT(model.config)
+        x = torch.randint(0, 1, (train.micro_batch_size, meta_model.max_seq_length))
+        model_fwd = lambda: meta_model(x)  # noqa: F821
+        model_loss = lambda y: chunked_cross_entropy(y, x, chunk_size=0)  # noqa: F821
+        measured_flops = measure_flops(meta_model, model_fwd, model_loss)
+        fabric.print(f"Measured TFLOPs: {measured_flops * fabric.world_size / 1e12:.2f}")
+        del meta_model, x
+
+    val_loss = validate(fabric, model, val_dataloader, max_iters=eval.max_iters)
+    metrics = {"val_loss": val_loss, "val_ppl": math.exp(val_loss)}
+    fabric.log_dict(metrics, step=state["iter_num"])
+    fabric.print(f"Final evaluation | val loss: {val_loss.item():.3f} | val ppl: {math.exp(val_loss):.3f}")
+
+    if month is not None:
+        metrics = {
+            "month": month,
+            "val_loss": float(val_loss),
+            "val_ppl": float(math.exp(val_loss)),
+            "rank": fabric.global_rank,
+        }
+    else:
+        metrics = {
+            "val_loss": float(val_loss),
+            "val_ppl": float(math.exp(val_loss)),
+        }
+    jsonl_path = out_dir.parent / "ppl_metrics.jsonl"
+    os.makedirs(out_dir, exist_ok=True)
+    with open(jsonl_path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(metrics, ensure_ascii=False) + "\n")
+
+
+@torch.no_grad()
+def validate(
+    fabric: L.Fabric, model: nn.Module, val_dataloader: DataLoader, max_iters: int, verbose: bool = True
+) -> torch.Tensor:
+    fabric.barrier()
+    if verbose:
+        fabric.print("Validating ...")
+    model.eval()
+
+    losses = []
+    for k, batch in enumerate(val_dataloader):
+        if k >= max_iters:
+            break
+        input_ids = batch[:, 0 : model.max_seq_length].contiguous().long()
+        targets = batch[:, 1 : (model.max_seq_length + 1)].contiguous().long()
+        logits = model(input_ids)
+        loss = chunked_cross_entropy(logits, targets)
+        losses.append(loss)
+
+    val_loss = torch.stack(losses).mean()
+    model.train()
+    fabric.barrier()
+    return val_loss
+
+
+def get_dataloaders(
+    fabric: L.Fabric, data: DataModule, tokenizer: Tokenizer, train: TrainArgs, block_size: int
+) -> Tuple[DataLoader, DataLoader]:
+    data.connect(tokenizer=tokenizer, batch_size=train.micro_batch_size, max_seq_length=block_size)
+    with fabric.rank_zero_first():
+        data.prepare_data()
+    data.setup()
+    train_dataloader = data.train_dataloader()
+    val_dataloader = data.val_dataloader()
+    return train_dataloader, val_dataloader
+
+
+def save_checkpoint(fabric, state, tokenizer_dir, checkpoint_file):
+    model = state["model"]
+    checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
+    fabric.print(f"Saving checkpoint to {str(checkpoint_file)!r}")
+    fabric.save(checkpoint_file, state)
+    if fabric.global_rank == 0:
+        save_hyperparameters(setup, checkpoint_file.parent)
+        if tokenizer_dir is not None:
+            copy_config_files(tokenizer_dir, checkpoint_file.parent)
+        save_config(model.config, checkpoint_file.parent)
+
+def initialize_weights(fabric: L.Fabric, model: GPT, n_layer: int, n_embd: int) -> None:
+    """GPT-NeoX weight initialization (https://arxiv.org/abs/2204.06745)."""
+    # Adapted from https://github.com/jzhang38/TinyLlama
+
+    def init_weights(module, std):
+        nn.init.normal_(module.weight, mean=0.0, std=std)
+        if getattr(module, "bias", None) is not None:
+            nn.init.zeros_(module.bias)
+
+    for mod in model.modules():
+        if isinstance(mod, (nn.Embedding, nn.Linear)):
+            mod.reset_parameters = partial(init_weights, mod, std=math.sqrt(2.0 / 5 / n_embd))
+
+    # need a separate loop because `mod.proj` below is a `nn.Linear` too
+    for mod in model.modules():
+        if isinstance(mod, (LLaMAMLP, CausalSelfAttention)):
+            mod.proj.reset_parameters = partial(init_weights, mod.proj, std=(1 / math.sqrt(n_embd) / n_layer))
+
+    if not isinstance(fabric.strategy, FSDPStrategy):
+        reset_parameters(model)
+
+def validate_args(train: TrainArgs, eval: EvalArgs, initial_checkpoint_dir, resume) -> None:
+    issues = []
+    unsupported = [(train, ["max_steps", "epochs"]), (eval, ["max_new_tokens"])]
+    for args, names in unsupported:
+        for name in names:
+            if getattr(args, name) is not None:
+                issues.append(f"{__file__} doesn't support the {name!r} argument. This is set in {args}")
+    required = [(train, ["max_tokens", "max_norm"])]
+    for args, names in required:
+        for name in names:
+            if getattr(args, name) is None:
+                issues.append(f"{__file__} requires the {name!r} argument. This is set in {args}")
+    if initial_checkpoint_dir and resume:
+        issues.append("Can't provide both `--resume` and `--initial_checkpoint_dir`. Choose one.")
+    if issues:
+        raise ValueError("\n".join(issues))

litgpt/pretrain.py

@@ -0,0 +1,564 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import math
+import pprint
+import time
+import os
+import json
+from dataclasses import asdict
+from datetime import timedelta
+from functools import partial
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Union
+
+import lightning as L
+import torch
+import torch.nn as nn
+from lightning.fabric.strategies import FSDPStrategy
+from lightning.fabric.utilities.throughput import ThroughputMonitor, measure_flops
+from torch.utils.data import DataLoader
+from torchmetrics.aggregation import RunningMean
+from typing_extensions import Literal
+
+from litgpt import Tokenizer
+from litgpt.args import EvalArgs, LogArgs, TrainArgs
+from litgpt.config import name_to_config
+from litgpt.data import DataModule, TinyLlama, Arxiv
+from litgpt.model import GPT, Block, CausalSelfAttention, Config, LLaMAMLP
+from litgpt.utils import (
+    CycleIterator,
+    capture_hparams,
+    check_nvlink_connectivity,
+    choose_logger,
+    chunked_cross_entropy,
+    copy_config_files,
+    extend_checkpoint_dir,
+    find_resume_path,
+    get_default_supported_precision,
+    init_out_dir,
+    instantiate_torch_optimizer,
+    num_parameters,
+    parse_devices,
+    reset_parameters,
+    save_config,
+    save_hyperparameters,
+)
+
+
+def setup(
+    model_name: str,
+    model_config: Optional[Config] = None,
+    out_dir: Path = Path("out/pretrain"),
+    precision: Literal["bf16-true", "bf16-mixed", "32-true", None] = None,
+    initial_checkpoint_dir: Optional[Path] = None,
+    resume: Union[bool, Literal["auto"], Path] = False,
+    data: Optional[DataModule] = None,
+    data_dir: Path = None,
+    train: TrainArgs = TrainArgs(
+        save_interval=1000,
+        log_interval=1,
+        global_batch_size=512,
+        micro_batch_size=4,
+        max_tokens=int(3e12),  # 3 trillion
+        max_norm=1.0,
+        min_lr=4e-5,
+        lr_warmup_steps=2000,
+        tie_embeddings=False,
+    ),
+    eval: EvalArgs = EvalArgs(interval=1000, max_iters=100),
+    log: LogArgs = LogArgs(),
+    optimizer: Union[str, Dict] = "AdamW",
+    devices: Union[int, str] = "auto",
+    num_nodes: int = 1,
+    tokenizer_dir: Optional[Path] = None,
+    logger_name: Literal["wandb", "tensorboard", "csv", "mlflow"] = "tensorboard",
+    seed: int = 42,
+):
+    """Pretrain a model.
+
+    Arguments:
+        model_name: The name of the model to pretrain. Choose from names in ``litgpt.config``. Use "list" to list the supported models.
+        model_config: A ``litgpt.Config`` object to define the model architecture. Mutually exclusive with
+            ``model_config``. Overrides the `model_name` if specified.
+        out_dir: Directory in which to save checkpoints and logs. If running in a Lightning Studio Job, look for it in
+            /teamspace/jobs/<job-name>/share.
+        precision: The precision to use for finetuning. Determines a compatible precision setting by default.
+        initial_checkpoint_dir: Optional path to a checkpoint directory to initialize the model from.
+            Useful for continued pretraining. Mutually exclusive with ``resume``.
+        resume: Path to a checkpoint directory to resume from in case training was interrupted, or ``True`` to resume
+            from the latest checkpoint in ``out_dir``. An error will be raised if no checkpoint is found. Passing
+            ``'auto'`` will resume from the latest checkpoint but not error if no checkpoint exists.
+        data: Data-related arguments. If not provided, the default is ``litgpt.data.TinyLlama``.
+        train: Training-related arguments. See ``litgpt.args.TrainArgs`` for details.
+        eval: Evaluation-related arguments. See ``litgpt.args.EvalArgs`` for details.
+        optimizer: An optimizer name (such as "AdamW") or config.
+
+        devices: How many devices/GPUs to use. Uses all GPUs by default.
+        num_nodes: How many nodes the code is being run on.
+        tokenizer_dir: Optional path to the tokenizer dir that was used for preprocessing the dataset. Only some data
+            module require this.
+        logger_name: The name of the logger to send metrics to.
+        seed: The random seed to use for reproducibility.
+    """
+    if model_name == "list":
+        available_models = "\n".join(sorted(name_to_config))
+        print(f"Available values:\n{available_models}")
+        quit()
+
+    if initial_checkpoint_dir is not None:
+        initial_checkpoint_dir = extend_checkpoint_dir(initial_checkpoint_dir)
+
+    if tokenizer_dir is not None:
+        tokenizer_dir = extend_checkpoint_dir(tokenizer_dir)
+
+    if model_config is None:
+        # Support both model_name options: meta-llama/Meta-Llama-3-8B & Meta-Llama-3-8B
+        try:
+            model_config = Config.from_name(model_name)
+        except ValueError:
+            print(f"Model name {model_name} is not supported.\n")
+            available_models = "\n".join(sorted(name_to_config))
+            print(f"Available values:\n{available_models}")
+            quit()
+
+    hparams = capture_hparams()
+
+    from litgpt.data import Arxiv
+    if isinstance(data, Arxiv):
+        data.arxiv_train = str(data_dir).rstrip("/") + "/train"
+        data.arxiv_val = str(data_dir).rstrip("/") + "/train"
+    else:
+        data = TinyLlama() if data is None else data
+
+    config = Config.from_name(model_name) if model_config is None else model_config
+    precision = precision or get_default_supported_precision(training=True)
+    devices = parse_devices(devices)
+    out_dir = init_out_dir(out_dir)
+    # in case the dataset requires the Tokenizer
+    tokenizer = Tokenizer(tokenizer_dir) if tokenizer_dir is not None else None
+
+    logger = choose_logger(
+        logger_name,
+        out_dir,
+        name=f"pretrain-{config.name}",
+        resume=bool(resume),
+        log_interval=train.log_interval,
+        log_args=asdict(log),
+    )
+
+    if devices * num_nodes > 1:
+        strategy = FSDPStrategy(auto_wrap_policy={Block}, state_dict_type="full", sharding_strategy="HYBRID_SHARD")
+    else:
+        strategy = "auto"
+
+    fabric = L.Fabric(devices=devices, num_nodes=num_nodes, strategy=strategy, precision=precision, loggers=[logger])
+
+    if torch.cuda.is_available() and devices > 1:
+        check_nvlink_connectivity(fabric)
+
+    fabric.launch()
+
+    fabric.print(pprint.pformat(hparams))
+    if logger_name in ("tensorboard", "wandb", "mlflow"):
+        fabric.logger.log_hyperparams(hparams)
+
+    main(
+        fabric=fabric,
+        devices=devices,
+        num_nodes=num_nodes,
+        seed=seed,
+        initial_checkpoint_dir=initial_checkpoint_dir,
+        resume=resume,
+        config=config,
+        data=data,
+        out_dir=out_dir,
+        tokenizer_dir=tokenizer_dir,
+        tokenizer=tokenizer,
+        train=train,
+        eval=eval,
+        optimizer=optimizer,
+    )
+
+
+def main(
+    fabric: L.Fabric,
+    devices: int,
+    seed: int,
+    initial_checkpoint_dir: Optional[Path],
+    resume: Union[bool, Literal["auto"], Path],
+    config: Config,
+    data: DataModule,
+    out_dir: Path,
+    tokenizer_dir: Optional[Path],
+    tokenizer: Optional[Tokenizer],
+    train: TrainArgs,
+    eval: EvalArgs,
+    optimizer: Union[str, Dict],
+    num_nodes: int = 1,
+) -> None:
+    validate_args(train, eval, initial_checkpoint_dir, resume)
+
+    if fabric.global_rank == 0:
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+    fabric.seed_everything(seed)  # same seed for every process to init model (FSDP)
+
+    t0 = time.perf_counter()
+    with fabric.init_module(empty_init=True):
+        model = GPT(config)
+
+    initialize_weights(fabric, model, n_layer=config.n_layer, n_embd=config.n_embd)
+
+    if train.tie_embeddings:
+        model.transformer.wte.weight = model.lm_head.weight
+    if train.max_seq_length:
+        model.max_seq_length = train.max_seq_length
+
+    fabric.print(f"Time to instantiate model: {time.perf_counter() - t0:.02f} seconds.")
+    fabric.print(f"Total parameters: {num_parameters(model):,}")
+
+    model = torch.compile(model)
+    model = fabric.setup(model)
+
+    extra_kwargs = {"fused": fabric.device.type == "cuda"}
+    optimizer = instantiate_torch_optimizer(optimizer, model.parameters(), **extra_kwargs)
+    optimizer = fabric.setup_optimizers(optimizer)
+
+    train_dataloader, val_dataloader = get_dataloaders(fabric, data, tokenizer, train, model.max_seq_length)
+    train_dataloader, val_dataloader = fabric.setup_dataloaders(train_dataloader, val_dataloader)
+
+    if initial_checkpoint_dir:
+        ckpt_path = initial_checkpoint_dir / "lit_model.pth"
+
+        if fabric.global_rank == 0:
+            try:
+                obj = torch.load(ckpt_path, map_location="cpu")
+            except Exception as e:
+                raise RuntimeError(f"[load] 无法读取 {ckpt_path}: {e}")
+
+            if isinstance(obj, dict) and "model" in obj:
+                import os
+                print(f"[fix] {ckpt_path} 是整包 state，提取 model 权重并原子覆盖...", flush=True)
+                sd = obj["model"]
+                # 去掉可能的 'module.' 前缀
+                if len(sd) and next(iter(sd)).startswith("module."):
+                    sd = {k[7:]: v for k, v in sd.items()}
+
+                tmp = ckpt_path.with_suffix(".pth.tmp")
+                torch.save(sd, tmp)
+                os.replace(tmp, ckpt_path)  # 原子替换，避免半文件
+                try:
+                    os.sync()  # 刷盘（若权限允许）
+                except Exception:
+                    pass
+                print(f"[fix] 已覆盖为纯权重: {ckpt_path}", flush=True)
+            else:
+                print(f"[ok] {ckpt_path} 已是纯权重", flush=True)
+
+        fabric.barrier()
+
+        fabric.load_raw(ckpt_path, model, strict=False)
+
+    state = {
+        "model": model,
+        "optimizer": optimizer,
+        "train_dataloader": train_dataloader,
+        "iter_num": 0,
+        "step_count": 0,
+    }
+
+    resume = find_resume_path(resume, out_dir)
+    if resume:
+        fabric.print(f"Resuming training from {resume}")
+        fabric.load(resume, state)
+
+    train_time = time.perf_counter()
+
+    # work around PyTorch issue https://github.com/pytorch/pytorch/issues/152162
+    # which does not like the lazy initialization to be called in dynamo.
+    # Happens with PyTorch 2.7.
+    if (
+        torch.__version__.startswith("2.7.")
+        and (model._forward_module.__class__.__name__ == "OptimizedModule")
+        and (model._forward_module._orig_mod.__class__.__name__ == "FullyShardedDataParallel")
+    ):
+        from torch.distributed.fsdp._runtime_utils import _root_pre_forward
+
+        _root_pre_forward(model._forward_module._orig_mod, model._forward_module._orig_mod, [], {})
+
+    fit(
+        fabric=fabric,
+        devices=devices,
+        num_nodes=num_nodes,
+        state=state,
+        train_dataloader=train_dataloader,
+        val_dataloader=val_dataloader,
+        out_dir=out_dir,
+        tokenizer_dir=tokenizer_dir,
+        train=train,
+        eval=eval,
+    )
+
+    # Save final checkpoi
+    save_checkpoint(fabric, state, tokenizer_dir, out_dir / "final" / "lit_model.pth")
+
+    total_tokens = state["iter_num"] * train.micro_batch_size * model.max_seq_length * fabric.world_size
+
+    # Print formatted output
+    separator = "-" * 40
+    fabric.print(separator)
+    fabric.print("| Performance")
+    fabric.print(f"| - Total tokens  : {total_tokens:,}")
+    fabric.print(f"| - Training Time : {(time.perf_counter() - train_time):.2f} s")
+    fabric.print(f"| - Tok/sec       : {total_tokens / train_time:.2f} tok/s")
+    fabric.print("| " + "-" * 40)
+
+    if fabric.device.type == "cuda":
+        memory_used = torch.cuda.max_memory_allocated() / 1e9
+        fabric.print("| Memory Usage")
+        fabric.print(f"| - Memory Used   : {memory_used:.2f} GB")
+    fabric.print(separator)
+
+
+def fit(
+    fabric: L.Fabric,
+    devices: int,
+    state: dict,
+    train_dataloader: DataLoader,
+    val_dataloader: DataLoader,
+    out_dir: Path,
+    tokenizer_dir: Optional[Path],
+    train: TrainArgs,
+    eval: EvalArgs,
+    num_nodes: int = 1,
+) -> None:
+    model = state["model"]
+    optimizer = state["optimizer"]
+
+    if eval.initial_validation:
+        val_loss = validate(fabric, model, val_dataloader, max_iters=eval.max_iters)
+        val_loss = f"{val_loss:.3f}"
+    else:
+        fabric.print("Verifying settings ...")
+        validate(fabric, model, val_dataloader, max_iters=2, verbose=False)  # sanity check
+        val_loss = "n/a"
+
+    throughput = ThroughputMonitor(fabric, window_size=5)
+
+    with torch.device("meta"):
+        meta_model = GPT(model.config)
+        x = torch.randint(0, 1, (train.micro_batch_size, meta_model.max_seq_length))
+        model_fwd = lambda: meta_model(x)  # noqa: F821
+        model_loss = lambda y: chunked_cross_entropy(y, x, chunk_size=0)  # noqa: F821
+        measured_flops = measure_flops(meta_model, model_fwd, model_loss)
+        fabric.print(f"Measured TFLOPs: {measured_flops * fabric.world_size / 1e12:.2f}")
+        del meta_model, x
+
+
+    max_tokens_per_device = train.max_tokens // fabric.world_size
+    tokens_per_iter = train.micro_batch_size * model.max_seq_length
+    max_iters = max_tokens_per_device // tokens_per_iter
+    log_iter_interval = train.log_interval * train.gradient_accumulation_iters(devices, num_nodes)
+    initial_iter = state["iter_num"]
+    train_iterator = CycleIterator(train_dataloader)
+
+    running_loss = RunningMean(window=train.gradient_accumulation_iters(devices, num_nodes), sync_on_compute=False).to(
+        fabric.device
+    )
+    fabric.barrier()
+    total_t0 = time.perf_counter()
+
+    warmup_iters = train.warmup_iters(devices, num_nodes, max_iters, train_dataloader)
+
+    for train_data in train_iterator:
+        if state["iter_num"] >= max_iters:
+            break
+
+        # determine and set the learning rate for this iteration
+        lr = get_lr(optimizer.defaults["lr"], state["iter_num"], warmup_iters, max_iters, train.min_lr)
+        for param_group in optimizer.param_groups:
+            param_group["lr"] = lr
+
+        state["iter_num"] += 1
+        iter_t0 = time.perf_counter()
+
+        input_ids = train_data[:, 0 : model.max_seq_length].contiguous().long()
+        targets = train_data[:, 1 : (model.max_seq_length + 1)].contiguous().long()
+
+        is_accumulating = state["iter_num"] % train.gradient_accumulation_iters(devices, num_nodes) != 0
+        with fabric.no_backward_sync(model, enabled=is_accumulating):
+            logits = model(input_ids)
+            loss = chunked_cross_entropy(logits, targets)
+            fabric.backward(loss / train.gradient_accumulation_iters(devices, num_nodes))
+
+        running_loss.update(loss.detach())
+
+        if not is_accumulating:
+            fabric.clip_gradients(model, optimizer, max_norm=train.max_norm)
+            optimizer.step()
+            optimizer.zero_grad()
+            state["step_count"] += 1
+
+        if state["iter_num"] % log_iter_interval == 0:
+            loss = running_loss.compute().item()  # expensive device-to-host synchronization
+            t1 = time.perf_counter()
+            throughput.update(
+                time=(t1 - total_t0),
+                flops=(measured_flops * log_iter_interval),
+                batches=state["iter_num"],
+                samples=(state["iter_num"] * train.micro_batch_size),
+                lengths=(state["iter_num"] * train.micro_batch_size * model.max_seq_length),
+            )
+            metrics = {
+                "loss": loss,
+                "iter": state["iter_num"],
+                "step": state["step_count"],
+                "epoch": train_iterator.epoch,
+                "iter_time": t1 - iter_t0,
+                "remaining_time": (
+                    (t1 - total_t0) / (state["iter_num"] - initial_iter) * (max_iters - state["iter_num"])
+                ),
+                "tokens": state["iter_num"] * train.micro_batch_size * model.max_seq_length,
+                "total_tokens": (state["iter_num"] * train.micro_batch_size * model.max_seq_length * fabric.world_size),
+                "learning_rate": lr,
+            }
+            if isinstance(val_loss, float):
+                val_loss = f"{val_loss:.3f}"
+            fabric.print(
+                f"Epoch {metrics['epoch'] + 1} | iter {metrics['iter']} step {metrics['step']} |"
+                f" loss train: {metrics['loss']:.3f},"
+                f" val: {val_loss} |"
+                f" iter time: {metrics['iter_time'] * 1000:.2f} ms"
+                f"{' (step)' if not is_accumulating else ''}"
+                f" remaining time: {timedelta(seconds=int(metrics['remaining_time']))!s}",
+                flush=True
+            )
+
+            throughput_metrics = throughput.compute()
+            metrics.update(throughput_metrics)
+            fabric.log_dict(metrics, step=state["iter_num"] - 1)
+
+        if val_dataloader is not None and not is_accumulating and state["step_count"] % eval.interval == 0:
+            t0 = time.perf_counter()
+            val_loss = validate(fabric, model, val_dataloader, max_iters=eval.max_iters)
+            val_loss = val_loss.item()
+            td = time.perf_counter() - t0
+
+            fabric.print(f"iter {state['iter_num']}: val loss {val_loss:.4f}, val time: {td * 1000:.2f} ms")
+            metrics = {"val_loss": val_loss, "val_ppl": math.exp(val_loss)}
+            fabric.log_dict(metrics, step=state["iter_num"] - 1)
+            fabric.barrier()
+
+        if train.save_interval is not None and not is_accumulating and state["step_count"] % train.save_interval == 0:
+            save_checkpoint(fabric, state, tokenizer_dir, out_dir / f"step-{state['step_count']:08d}" / "lit_model.pth")
+
+    # Final validation
+    if eval.final_validation:
+        val_loss = validate(fabric, model, val_dataloader, max_iters=eval.max_iters)
+        metrics = {"val_loss": val_loss, "val_ppl": math.exp(val_loss)}
+        fabric.log_dict(metrics, step=state["iter_num"])
+        fabric.print(f"Final evaluation | val loss: {val_loss.item():.3f} | val ppl: {math.exp(val_loss):.3f}")
+
+
+@torch.no_grad()
+def validate(
+    fabric: L.Fabric, model: nn.Module, val_dataloader: DataLoader, max_iters: int, verbose: bool = True
+) -> torch.Tensor:
+    fabric.barrier()
+    if verbose:
+        fabric.print("Validating ...")
+    model.eval()
+
+    losses = []
+    for k, batch in enumerate(val_dataloader):
+        if k >= max_iters:
+            break
+        input_ids = batch[:, 0 : model.max_seq_length].contiguous().long()
+        targets = batch[:, 1 : (model.max_seq_length + 1)].contiguous().long()
+        logits = model(input_ids)
+        loss = chunked_cross_entropy(logits, targets)
+        losses.append(loss)
+
+    val_loss = torch.stack(losses).mean()
+    model.train()
+    fabric.barrier()
+    return val_loss
+
+
+def get_dataloaders(
+    fabric: L.Fabric, data: DataModule, tokenizer: Tokenizer, train: TrainArgs, block_size: int
+) -> Tuple[DataLoader, DataLoader]:
+    data.connect(tokenizer=tokenizer, batch_size=train.micro_batch_size, max_seq_length=block_size)
+    with fabric.rank_zero_first():
+        data.prepare_data()
+    data.setup()
+    train_dataloader = data.train_dataloader()
+    val_dataloader = data.val_dataloader()
+    return train_dataloader, val_dataloader
+
+
+# learning rate decay scheduler (cosine with linear warmup)
+def get_lr(learning_rate: float, it: int, warmup_iters: int, max_iters: int, min_lr: float) -> float:
+    # 1) linear warmup for warmup_iters steps
+    if it < warmup_iters:
+        return learning_rate * it / warmup_iters
+    # 2) if it > max_iters, return min learning rate
+    if it > max_iters:
+        return min_lr
+    # 3) in between, use cosine decay down to min learning rate
+    decay_ratio = (it - warmup_iters) / (max_iters - warmup_iters)
+    assert 0 <= decay_ratio <= 1
+    coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio))  # coeff ranges 0..1
+    return min_lr + coeff * (learning_rate - min_lr)
+
+
+def initialize_weights(fabric: L.Fabric, model: GPT, n_layer: int, n_embd: int) -> None:
+    """GPT-NeoX weight initialization (https://arxiv.org/abs/2204.06745)."""
+    # Adapted from https://github.com/jzhang38/TinyLlama
+
+    def init_weights(module, std):
+        nn.init.normal_(module.weight, mean=0.0, std=std)
+        if getattr(module, "bias", None) is not None:
+            nn.init.zeros_(module.bias)
+
+    for mod in model.modules():
+        if isinstance(mod, (nn.Embedding, nn.Linear)):
+            mod.reset_parameters = partial(init_weights, mod, std=math.sqrt(2.0 / 5 / n_embd))
+
+    # need a separate loop because `mod.proj` below is a `nn.Linear` too
+    for mod in model.modules():
+        if isinstance(mod, (LLaMAMLP, CausalSelfAttention)):
+            mod.proj.reset_parameters = partial(init_weights, mod.proj, std=(1 / math.sqrt(n_embd) / n_layer))
+
+    if not isinstance(fabric.strategy, FSDPStrategy):
+        reset_parameters(model)
+
+
+def save_checkpoint(fabric, state, tokenizer_dir, checkpoint_file):
+    model = state["model"]
+    checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
+    fabric.print(f"Saving checkpoint to {str(checkpoint_file)!r}")
+    fabric.save(checkpoint_file, state)
+    if fabric.global_rank == 0:
+        save_hyperparameters(setup, checkpoint_file.parent)
+        if tokenizer_dir is not None:
+            copy_config_files(tokenizer_dir, checkpoint_file.parent)
+        save_config(model.config, checkpoint_file.parent)
+
+
+def validate_args(train: TrainArgs, eval: EvalArgs, initial_checkpoint_dir, resume) -> None:
+    issues = []
+    unsupported = [(train, ["max_steps", "epochs"]), (eval, ["max_new_tokens"])]
+    for args, names in unsupported:
+        for name in names:
+            if getattr(args, name) is not None:
+                issues.append(f"{__file__} doesn't support the {name!r} argument. This is set in {args}")
+    required = [(train, ["max_tokens", "max_norm"])]
+    for args, names in required:
+        for name in names:
+            if getattr(args, name) is None:
+                issues.append(f"{__file__} requires the {name!r} argument. This is set in {args}")
+    if initial_checkpoint_dir and resume:
+        issues.append("Can't provide both `--resume` and `--initial_checkpoint_dir`. Choose one.")
+    if issues:
+        raise ValueError("\n".join(issues))

litgpt/prompts.py

@@ -0,0 +1,541 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+import importlib
+import re
+from abc import abstractmethod
+from json import dumps
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Type, Union
+
+import yaml
+
+from litgpt.config import Config
+
+if TYPE_CHECKING:
+    from litgpt import Tokenizer
+
+
+class PromptStyle:
+    """Base interface for prompt styles."""
+
+    @abstractmethod
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return prompt
+
+    def stop_tokens(self, tokenizer: "Tokenizer") -> Tuple[List[int], ...]:
+        return ([tokenizer.eos_id],)
+
+    @classmethod
+    def from_name(cls, name: str) -> "PromptStyle":
+        return prompt_styles[name]()
+
+    @classmethod
+    def from_config(cls, config: Config) -> "PromptStyle":
+        return model_name_to_prompt_style(config.name)
+
+
+class Default(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return prompt
+
+    def stop_tokens(self, tokenizer: "Tokenizer") -> Tuple[List[int], ...]:
+        return ([tokenizer.eos_id],)
+
+
+class Alpaca(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        if kwargs.get("input"):
+            sys_prompt = sys_prompt or (
+                "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"
+            )
+            return f"{sys_prompt}### Instruction:\n{prompt}\n\n### Input:\n{kwargs['input']}\n\n### Response:\n"
+
+        sys_prompt = sys_prompt or (
+            "Below is an instruction that describes a task. "
+            "Write a response that appropriately completes the request.\n\n"
+        )
+        return f"{sys_prompt}### Instruction:\n{prompt}\n\n### Response:\n"
+
+
+class FLAN(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = sys_prompt or (
+            "Below is an instruction that describes a task. "
+            "Write a response that appropriately completes the request.\n\n"
+        )
+        return f"{sys_prompt}### Instruction:\n{prompt}\n\n### Response:\n"
+
+
+class Longform(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = sys_prompt or (
+            "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"
+        )
+        return f"{sys_prompt}### Instruction:\n{prompt}\n\n### Response:\n"
+
+
+class StableLMAlpha(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = sys_prompt or (
+            "# StableLM Tuned (Alpha version)\n- StableLM is a helpful and harmless open-source AI language"
+            " model developed by StabilityAI.\n- StableLM is excited to be able to help the user, but will refuse to do"
+            " anything that could be considered harmful to the user.\n- StableLM is more than just an information"
+            " source, StableLM is also able to write poetry, short stories, and make jokes.\n- StableLM will refuse to"
+            " participate in anything that could harm a human."
+        )
+        return f"<|SYSTEM|>{sys_prompt}<|USER|>{prompt}<|ASSISTANT|>"
+
+    def stop_tokens(self, tokenizer: "Tokenizer") -> Tuple[List[int], ...]:
+        return (
+            [tokenizer.eos_id],
+            [tokenizer.token_to_id("<|SYSTEM|>")],
+            [tokenizer.token_to_id("<|ASSISTANT|>")],
+            [tokenizer.token_to_id("<|USER|>")],
+        )
+
+
+class StableLMZephyr(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"<|user|>\n{prompt}<|endoftext|>\n<|assistant|>\n"
+
+
+class Falcon(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"{prompt}\nAnswer:"
+
+    def stop_tokens(self, tokenizer: "Tokenizer") -> Tuple[List[int], ...]:
+        return (
+            [tokenizer.eos_id],
+            # the model rarely emits the eos token and instead outputs newlines, but we cannot use them
+            # to stop or else things like code generation wouldn't work
+            [tokenizer.token_to_id("User"), tokenizer.token_to_id(":")],
+            [193, tokenizer.token_to_id("User")],  # 193: '\n'
+        )
+
+
+class Falcon3(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"<|user|>\n{prompt}<|endoftext|>\n<|assistant|>\n"
+
+    def stop_tokens(self, tokenizer: "Tokenizer") -> Tuple[List[int], ...]:
+        return (
+            [tokenizer.eos_id],
+            [tokenizer.token_to_id("<|endoftext|>")],
+        )
+
+
+class Llama2FunctionCalling(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        # Has to be before the llama config
+        b_func, e_func = "<FUNCTIONS>", "</FUNCTIONS>\n\n"
+        b_inst, e_inst = "[INST]", "[/INST]"
+        b_sys, e_sys = "<<SYS>>\n", "\n<</SYS>>\n\n"
+        # This is an example for how to format functions for the model
+        function_metadata = {
+            "function": "search_bing",
+            "description": (
+                "Search the web for content on Bing. This allows users to search online/the internet/the web for"
+                " content."
+            ),
+            "arguments": [{"name": "query", "type": "string", "description": "The search query string"}],
+        }
+
+        system_prompt = sys_prompt or (
+            "You are a helpful, respectful and honest assistant. Always answer as helpfully as"
+            "possible. Your only response should be JSON formatted functions"
+        )
+        # replace the curly braces with double curly braces to escape them
+        function_list = dumps(function_metadata).replace("{", "{{").replace("}", "}}")
+        return (
+            f"{b_func}{function_list.strip()}{e_func}{b_inst}{b_sys}{system_prompt.strip()}{e_sys}{prompt}{e_inst}\n\n"
+        )
+
+
+class Llama2(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        b_inst, e_inst = "[INST]", "[/INST]"
+        b_sys, e_sys = "<<SYS>>\n", "\n<</SYS>>\n\n"
+        sys_prompt = sys_prompt or (
+            "You are a helpful, respectful and honest assistant. Always answer as helpfully as"
+            " possible, while being safe.  Your answers should not include any harmful, unethical, racist, sexist,"
+            " toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and"
+            " positive in nature.\n\nIf a question does not make any sense, or is not factually coherent, explain why"
+            " instead of answering something not correct. If you don't know the answer to a question, please don't"
+            " share false information."
+        )
+        return f"{b_inst} {b_sys}{sys_prompt}{e_sys} {prompt} {e_inst} "
+
+
+class Llama3(PromptStyle):
+    def apply(
+        self, prompt: Union[str, List[Dict[str, str]]], *, sys_prompt: Optional[str] = None, **kwargs: str
+    ) -> str:
+        default_system_prompt = sys_prompt or "You are a helpful assistant."
+
+        # https://github.com/meta-llama/llama3/blob/359887376f0aaf30e433f23e25df858d8c2a9833/llama/tokenizer.py#L202-L229
+        if isinstance(prompt, str):
+            return (
+                "<|begin_of_text|><|start_header_id|>system<|end_header_id|>\n\n"
+                f"{default_system_prompt}<|eot_id|>"  # No newline
+                "<|start_header_id|>user<|end_header_id|>\n\n"
+                f"{prompt}<|eot_id|>"  # No newline
+                "<|start_header_id|>assistant<|end_header_id|>\n\n"
+            )
+        elif isinstance(prompt, list):
+
+            def encode_header(role: str) -> List[str]:
+                return [f"<|start_header_id|>{role}<|end_header_id|>\n\n"]
+
+            def encode_message(message: Dict[str, str]) -> List[str]:
+                tokens = encode_header(message["role"])
+                # NOTE: Meta stripped this. I'm not sure I agree, but who am I to argue?
+                tokens.append(message["content"].strip())
+                tokens.append("<|eot_id|>")
+                return tokens
+
+            def has_system_prompt(messages: List[Dict[str, str]]) -> bool:
+                return messages[0].get("role", "") == "system" if len(messages) else False
+
+            tokens = ["<|begin_of_text|>"]
+            if not has_system_prompt(prompt):
+                tokens.extend(encode_message({"role": "system", "content": default_system_prompt}))
+            for i, message in enumerate(prompt):
+                if i != 0 and message["role"] == "system":
+                    raise ValueError("'system' role is only allowed at the beginning of the conversation list.")
+                if message["role"] not in ["assistant", "user", "system"]:
+                    raise ValueError(
+                        f"Unknown role: '{message['role']}'. Supported roles are 'assistant', 'user', and 'system'."
+                    )
+                tokens.extend(encode_message(message))
+            tokens.extend(encode_header("assistant"))
+            return "".join(tokens)
+        else:
+            raise ValueError(f"Unsupported prompt type: {type(prompt)}")
+
+    def stop_tokens(self, tokenizer: "Tokenizer") -> Tuple[List[int], ...]:
+        return (
+            [tokenizer.eos_id],
+            [tokenizer.token_to_id("<|eot_id|>")],
+        )
+
+
+class R1Base(PromptStyle):
+    def apply(
+        self, prompt: Union[str, List[Dict[str, str]]], *, sys_prompt: Optional[str] = None, **kwargs: str
+    ) -> str:
+        default_system_prompt = sys_prompt or ""
+
+        bos_token = "<｜begin▁of▁sentence｜>"
+        eos_token = ""
+
+        if isinstance(prompt, str):
+            return f"{default_system_prompt}<｜User｜>{prompt}<｜Assistant｜>"  # Prepares for assistant response
+        elif isinstance(prompt, list):
+
+            def encode_message(message: Dict[str, str]) -> str:
+                role = message["role"]
+                content = message["content"].strip()
+
+                if role == "system":
+                    return content  # System prompt is prepended at the start
+                elif role == "user":
+                    return f"<｜User｜>{content}"
+                elif role == "assistant":
+                    return f"<｜Assistant｜>{content}{eos_token}"
+                else:
+                    raise ValueError(f"Unknown role: '{role}'. Supported roles are 'assistant', 'user', and 'system'.")
+
+            # Extract system prompt (if any)
+            system_prompt = ""
+            if prompt[0].get("role") == "system":
+                system_prompt = prompt[0]["content"]
+                prompt = prompt[1:]  # Remove system message from the list
+
+            # Construct the formatted prompt
+            formatted_prompt = system_prompt
+            for message in prompt:
+                formatted_prompt += encode_message(message)
+
+            formatted_prompt += "<｜Assistant｜>"  # Prepares for assistant response
+            return formatted_prompt
+        else:
+            raise ValueError(f"Unsupported prompt type: {type(prompt)}")
+
+    def stop_tokens(self, tokenizer: "Tokenizer") -> Tuple[List[int], ...]:
+        return (
+            [tokenizer.eos_id],
+            [tokenizer.token_to_id("<｜end▁of▁sentence｜>")],
+        )
+
+
+class FreeWilly2(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = sys_prompt or "This is a system prompt, please behave and help the user."
+        return f"### System:\n{sys_prompt}\n\n### User:\n{prompt}\n\n### Assistant:\n"
+
+
+class Platypus(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"### Instruction:\n\n{prompt}\n\n### Response:\n"
+
+
+class StableCode(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"###Instruction\n{prompt}###Response\n"
+
+
+class CodeLlama(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        # for CodeLLama, we don't set a default system prompt, but it is supported:
+        # https://huggingface.co/blog/codellama#conversational-instructions
+        # Mistral does not: https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.1#instruction-format
+        b_inst, e_inst = "[INST]", "[/INST]"
+        if sys_prompt:
+            b_sys, e_sys = "<<SYS>>\n", "\n<</SYS>>\n\n"
+            return f"{b_inst} {b_sys}{sys_prompt}{e_sys}{prompt} {e_inst}"
+        return f"{b_inst} {prompt} {e_inst}"
+
+
+class Phi1(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"{prompt}\n\nAnswer:"
+
+    def stop_tokens(self, tokenizer: "Tokenizer") -> Tuple[List[int], ...]:
+        return (
+            [tokenizer.eos_id],
+            [tokenizer.token_to_id("Answer"), tokenizer.token_to_id(":")],
+            [198, tokenizer.token_to_id("Answer"), tokenizer.token_to_id(":")],
+            # the model rarely emits the eos token and instead outputs newlines, but we cannot use them
+            # to stop or else things like code generation wouldn't work
+            # [198, 198],  # '\n', '\n'
+        )
+
+
+class Phi2(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"Instruct: {prompt}\nOutput:"
+
+
+class Phi3(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = sys_prompt or "You are a helpful assistant."
+        return f"<|system|>\n{sys_prompt}<|end|>\n<|user|>\n{prompt}<|end|>\n<|assistant|>\n"
+
+
+class Phi4(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        res = ""
+        if sys_prompt:
+            res += f"<|im_start|>system<|im_sep|>{sys_prompt}<|im_end|>"
+        res += f"<|im_start|>user<|im_sep|>{prompt}<|im_end|><|im_start|>assistant<|im_sep|>"
+        return res
+
+
+class Phi4Reasoning(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = (
+            sys_prompt
+            or "You are Phi, a language model trained by Microsoft to help users. Your role as an assistant involves thoroughly exploring questions through a systematic thinking process before providing the final precise and accurate solutions. This requires engaging in a comprehensive cycle of analysis, summarizing, exploration, reassessment, reflection, backtracing, and iteration to develop well-considered thinking process. Please structure your response into two main sections: Thought and Solution using the specified format: <think> {Thought section} </think> {Solution section}. In the Thought section, detail your reasoning process in steps. Each step should include detailed considerations such as analysing questions, summarizing relevant findings, brainstorming new ideas, verifying the accuracy of the current steps, refining any errors, and revisiting previous steps. In the Solution section, based on various attempts, explorations, and reflections from the Thought section, systematically present the final solution that you deem correct. The Solution section should be logical, accurate, and concise and detail necessary steps needed to reach the conclusion. Now, try to solve the following question through the above guidelines:"
+        )
+        return f"<|im_start>system<|im_sep|>{sys_prompt}<|im_end|><|im_start|>user<|im_sep|>{prompt}<|im_end|><|im_start|>assistant<|im_sep|>"
+
+
+class Phi4Mini(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        res = ""
+        if sys_prompt:
+            res += f"<|system|>{sys_prompt}<|end|>"
+        res += f"<|user|>{prompt}<|end|><|assistant|>"
+        return res
+
+
+class Phi4MiniReasoning(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = sys_prompt or "Your name is Phi, an AI math expert developed by Microsoft."
+        return f"<|system|>{sys_prompt}<|end|><|user|>{prompt}<|end|><|assistant|>"
+
+
+class TinyLlama(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = sys_prompt or "You are a friendly chatbot who always gives helpful, detailed, and polite answers."
+        return f"<|system|>\n{sys_prompt}</s>\n<|user|>\n{prompt}</s>\n<|assistant|>\n"
+
+
+class Gemma(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"<start_of_turn>user\n{prompt}<end_of_turn>\n<start_of_turn>model\n"
+
+
+class OLMo(PromptStyle):
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        return f"<|endoftext|><|user|>\n{prompt}\n<|assistant|>\n"
+
+
+class ChatML(PromptStyle):
+    def __init__(self, system_message: Optional[str] = None):
+        self.system_message = system_message
+
+    def apply(self, prompt: str, *, sys_prompt: Optional[str] = None, **kwargs: str) -> str:
+        sys_prompt = sys_prompt or self.system_message
+        return (
+            f"<|im_start|>system\n{sys_prompt}<|im_end|>\n<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+        )
+
+
+class Qwen2_5(ChatML):
+    def __init__(self):
+        super().__init__("You are Qwen, created by Alibaba Cloud. You are a helpful assistant.")
+
+
+class Qwen2_5_Math(ChatML):
+    def __init__(self):
+        super().__init__("Please reason step by step, and put your final answer within \\boxed{}.")
+
+
+class QwQ(ChatML):
+    def __init__(self):
+        super().__init__(
+            "You are a helpful and harmless assistant. You are Qwen developed by Alibaba. You should think step-by-step."
+        )
+
+
+class Qwen3(ChatML):
+    def __init__(self):
+        super().__init__()
+
+
+class SmolLM2(ChatML):
+    def __init__(self):
+        super().__init__("You are a helpful AI assistant named SmolLM, trained by Hugging Face")
+
+
+class Salamandra(ChatML):
+    def __init__(self):
+        super().__init__(
+            "I am Salamandra, an AI language model developed at the Barcelona Supercomputing Centre (BSC) by the Language Technologies Unit. My knowledge base was last updated on August 2023. Today Date: 2024-09-30\nSoy Salamandra, un modelo lingüístico de IA desarrollado en el Barcelona Supercomputing Centre (BSC) por la Language Technologies Unit. Mi base de conocimientos se actualizó por última vez en agosto de 2023.\nSoc Salamandra, un model de llenguatge d'IA desenvolupat al Barcelona Supercomputing Centre (BSC) per la Language Technologies Unit."
+        )
+
+
+# Maps prompt style names to PromptStyle classes
+prompt_styles: Dict[str, Type[PromptStyle]] = {
+    # Dataset-specific prompt styles
+    "default": Default,
+    "alpaca": Alpaca,
+    "flan": FLAN,
+    "longform": Longform,
+    # Model-specific prompt styles
+    "stablelm-alpha": StableLMAlpha,
+    "stablelm-zephyr": StableLMZephyr,
+    "falcon": Falcon,
+    "llama2-function-calling": Llama2FunctionCalling,
+    "llama2": Llama2,
+    "freewilly2": FreeWilly2,
+    "platypus": Platypus,
+    "stablecode": StableCode,
+    "codellama": CodeLlama,
+    "phi-1": Phi1,
+    "phi-2": Phi2,
+    "phi-3": Phi3,
+    "phi-4": Phi4,
+    "phi-4-reasoning": Phi4Reasoning,
+    "phi-4-mini": Phi4Mini,
+    "phi-4-mini-reasoning": Phi4MiniReasoning,
+    "tinyllama": TinyLlama,
+    "gemma": Gemma,
+    "llama3": Llama3,
+    "olmo": OLMo,
+    "qwen2.5": Qwen2_5,
+    "qwen2.5-math": Qwen2_5_Math,
+    "qwq": QwQ,
+    "qwen3": Qwen3,
+    "smollm2": SmolLM2,
+    "salamandra": Salamandra,
+}
+
+
+def model_name_to_prompt_style(model_name: str) -> PromptStyle:
+    if re.search(r"stablelm-tuned-alpha", model_name):
+        return StableLMAlpha()
+    if re.search(r"stablelm-zephyr-3b", model_name):
+        return StableLMZephyr()
+    if re.search("stablecode-instruct", model_name):
+        return StableCode()
+    if re.search(r"Falcon3.*-Instruct", model_name):
+        return Falcon3()
+    if re.search(r"falcon.*-instruct", model_name):
+        return Falcon()
+    if re.search("Llama-2-7b-chat-hf-function-calling-v2", model_name):
+        return Llama2FunctionCalling()
+    if re.search("Llama-2.*-chat", model_name):
+        return Llama2()
+    if re.search("Llama-3.*-Instruct", model_name):
+        return Llama3()
+    if re.search("Llama-3.*-Instruct-*", model_name):
+        return Llama3()
+    if re.search("OLMo-2.*-(Instruct|SFT|DPO)", model_name):
+        return Llama3()
+    if re.search("R1", model_name):
+        return R1Base()
+    if re.search("FreeWilly2", model_name):
+        return FreeWilly2()
+    if re.search("Platypus", model_name):
+        return Platypus()
+    if re.search("CodeLlama|Mi[sx]tral.*Instruct", model_name):
+        return CodeLlama()
+    if re.search("phi-1", model_name):
+        return Phi1()
+    if re.search("phi-2", model_name):
+        return Phi2()
+    if re.search("Phi-3", model_name):
+        return Phi3()
+    if re.search("Phi-4-reasoning", model_name):
+        return Phi4Reasoning()
+    if re.search("Phi-4-mini-reasoning", model_name):
+        return Phi4MiniReasoning()
+    if re.search("Phi-4-mini", model_name):
+        return Phi4Mini()
+    if re.search("phi-4", model_name):
+        return Phi4()
+    if re.search(r"tiny-llama.*chat", model_name):
+        return TinyLlama()
+    if re.search(r"(Code)?Gemma.*-it", model_name):
+        return Gemma()
+    if re.search(r"OLMo.*-hf", model_name):
+        return OLMo()
+    if re.search(r"Qwen2\.5-Math-.*", model_name):
+        return Qwen2_5_Math()
+    if re.search(r"Qwen2\.5-.*", model_name):
+        return Qwen2_5()
+    if re.search(r"QwQ-.*", model_name):
+        return QwQ()
+    if re.search(r"Qwen3-.*", model_name):
+        return Qwen3()
+    if re.search(r"SmolLM2.*-Instruct", model_name):
+        return SmolLM2()
+    if re.search(r"salamandra-.*-instruct", model_name):
+        return Salamandra()
+    return Default()
+
+
+def save_prompt_style(style: Union[str, PromptStyle], checkpoint_dir: Path) -> None:
+    style = PromptStyle.from_name(style) if isinstance(style, str) else style
+    cls = type(style)
+    # Allow saving the full module path for user-defined prompt classes
+    config = {"class_path": f"{cls.__module__}.{cls.__name__}"}
+    with open(checkpoint_dir / "prompt_style.yaml", "w", encoding="utf-8") as file:
+        yaml.dump(config, file)
+
+
+def load_prompt_style(checkpoint_dir: Path) -> PromptStyle:
+    with open(checkpoint_dir / "prompt_style.yaml", encoding="utf-8") as file:
+        config = yaml.safe_load(file)
+    # Support loading the full module path for user-defined prompt classes
+    full_module_path, cls_name = config["class_path"].rsplit(".", 1)
+    module = importlib.import_module(full_module_path)
+    cls = getattr(module, cls_name)
+    return cls()
+
+
+def has_prompt_style(checkpoint_dir: Path) -> bool:
+    return (checkpoint_dir / "prompt_style.yaml").is_file()

litgpt/tokenizer.py

@@ -0,0 +1,182 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+import json
+from pathlib import Path
+from typing import Iterable, Iterator, Optional, Union
+
+import torch
+
+from litgpt.utils import fix_and_load_json
+
+
+class Tokenizer:
+    def __init__(self, checkpoint_dir: Union[Path, str]) -> None:
+        checkpoint_dir = Path(checkpoint_dir)
+        if not checkpoint_dir.exists():
+            raise NotADirectoryError(f"The checkpoint directory does not exist: {str(checkpoint_dir)}")
+
+        self.model_name = checkpoint_dir.stem
+        self.use_bos = self.check_if_bos_token_used(checkpoint_dir)
+        self.bos_id = None
+        self.eos_id = None
+
+        # some checkpoints have both files, `.json` takes precedence
+        if (vocabulary_path := checkpoint_dir / "tokenizer.json").is_file():
+            from tokenizers import Tokenizer as HFTokenizer
+
+            self.processor = HFTokenizer.from_file(str(vocabulary_path))
+            self.backend = "huggingface"
+
+            if (special_tokens_path := checkpoint_dir / "tokenizer_config.json").is_file():
+                with open(special_tokens_path, encoding="utf-8") as fp:
+                    config = json.load(fp)
+                bos_token = config.get("bos_token")
+                eos_token = config.get("eos_token")
+                if bos_token is not None and isinstance(bos_token, dict):
+                    bos_token = bos_token.get("content")
+                if eos_token is not None and isinstance(eos_token, dict):
+                    eos_token = eos_token.get("content")
+                self.bos_id = self.token_to_id(bos_token) if bos_token is not None else None
+                self.eos_id = self.token_to_id(eos_token) if eos_token is not None else None
+            if (special_tokens_path := checkpoint_dir / "generation_config.json").is_file():
+                try:
+                    with open(special_tokens_path, encoding="utf-8") as fp:
+                        config = json.load(fp)
+                except json.JSONDecodeError:  # Some files like the Llama 3.2 one have bugs
+                    with open(special_tokens_path, encoding="utf-8") as fp:
+                        json_string = fp.read()
+                        config = fix_and_load_json(json_string)
+                if self.bos_id is None:
+                    self.bos_id = config.get("bos_token_id")
+                if self.eos_id is None:
+                    self.eos_id = config.get("eos_token_id")
+
+        elif (vocabulary_path := checkpoint_dir / "tokenizer.model").is_file():
+            from sentencepiece import SentencePieceProcessor
+
+            self.processor = SentencePieceProcessor(model_file=str(vocabulary_path))
+            self.backend = "sentencepiece"
+            self.bos_id = self.processor.bos_id()
+            self.eos_id = self.processor.eos_id()
+        else:
+            raise NotImplementedError
+
+        # NOTE: A temporary fix until it's resolved on Tokenizers side.
+        # LlaMA tokenizer strips leading spaces if to decode a single token at a time.
+        # https://github.com/huggingface/transformers/issues/31643
+        self.apply_decoding_fix = None
+        if (config_path := checkpoint_dir / "tokenizer_config.json").is_file():
+            with open(config_path, encoding="utf-8") as fp:
+                self.apply_decoding_fix = "LlamaTokenizer" in json.load(fp)["tokenizer_class"]
+
+    @property
+    def vocab_size(self) -> int:
+        if self.backend == "huggingface":
+            return self.processor.get_vocab_size(with_added_tokens=False)
+        if self.backend == "sentencepiece":
+            return self.processor.vocab_size()
+        raise RuntimeError
+
+    def token_to_id(self, token: str) -> int:
+        if self.backend == "huggingface":
+            id_ = self.processor.token_to_id(token)
+        elif self.backend == "sentencepiece":
+            id_ = self.processor.piece_to_id(token)
+        else:
+            raise RuntimeError
+        if id_ is None:
+            raise ValueError(f"token {token!r} not found in the collection.")
+        return id_
+
+    def check_if_bos_token_used(self, checkpoint_dir: Path) -> bool:
+        if not (tokenizer_config_path := checkpoint_dir / "tokenizer_config.json").is_file():
+            return False
+        with open(tokenizer_config_path, encoding="utf-8") as fp:
+            config = json.load(fp)
+        # for LlaMA-3 tokenizer there is no `add_bos_token` at all and `tokenizer_class` is only
+        # `PreTrainedTokenizerFast`
+        if checkpoint_dir.stem.startswith(("Meta-Llama-3", "Llama-3")):
+            return True
+        if checkpoint_dir.stem.startswith("SmolLM2") and checkpoint_dir.name.endswith("Instruct"):
+            return True
+        if "add_bos_token" in config:
+            return config["add_bos_token"]
+        # if `add_bos_token` isn't in the config file, but LLaMA tokenizer is used - return True.
+        # ex: https://huggingface.co/stabilityai/StableBeluga2/blob/main/tokenizer_config.json#L2
+        return config.get("tokenizer_class") == "LlamaTokenizer"
+
+    def encode(
+        self,
+        string: str,
+        device: Optional[torch.device] = None,
+        bos: Optional[bool] = None,
+        eos: bool = False,
+        max_length: int = -1,
+    ) -> torch.Tensor:
+        if self.backend == "huggingface":
+            tokens = self.processor.encode(string).ids
+        elif self.backend == "sentencepiece":
+            tokens = self.processor.encode(string)
+        else:
+            raise RuntimeError(f"`{self.backend}` is not supported.")
+        if tokens is None:
+            raise ValueError("`self.processor` returned tokens of None value.")
+
+        if bos or (bos is None and self.use_bos):
+            if self.bos_id is None:
+                raise NotImplementedError("This tokenizer does not have a defined bos token.")
+            if not tokens or tokens[0] != self.bos_id:
+                tokens = [self.bos_id] + tokens
+        # if the processor misbehaves and adds `bos` token no matter what
+        elif tokens and tokens[0] == self.bos_id:
+            tokens = tokens[1:]
+
+        if eos and (not tokens or tokens[-1] != self.eos_id):
+            tokens = tokens + [self.eos_id]
+        # if the processor misbehaves and adds `eos` token no matter what
+        elif tokens and tokens[-1] == self.eos_id:
+            tokens = tokens[:-1]
+
+        if max_length > 0:
+            tokens = tokens[:max_length]
+        return torch.tensor(tokens, dtype=torch.int, device=device)
+
+    def decode(self, tensor: torch.Tensor) -> str:
+        tokens = [tensor.item()] if tensor.ndim == 0 else tensor.tolist()
+        if len(tokens) == 1 and self.apply_decoding_fix:
+            dummy_token_id = 33  # \x1e
+            dummy_token = self.processor.decode([dummy_token_id])
+            if dummy_token != "\x1e":
+                dummy_token_id = 165  # \x1e is different in salamandra tokenizers
+                dummy_token = self.processor.decode([dummy_token_id])
+            return self.processor.decode([dummy_token_id] + tokens)[len(dummy_token) :]
+        return self.processor.decode(tokens)
+
+    def decode_stream(
+        self, token_stream: Iterable[torch.Tensor], device: Optional[torch.device] = None
+    ) -> Iterator[str]:
+        if self.backend == "huggingface":
+            try:
+                for token in token_stream:
+                    yield self.decode(token)
+            except KeyboardInterrupt:
+                return
+        elif self.backend == "sentencepiece":
+            # TODO: Is there a way to not have to do this?
+            # This may actually affect our tokens per second.
+
+            # sentencepiece does not support decoding token-by-token because it adds spaces based on the surrounding tokens
+            # meaning that we need to decode everything each time
+            so_far = torch.tensor([], dtype=torch.long, device=device)
+            decoded_so_far = ""
+            try:
+                for token in token_stream:
+                    so_far = so_far.to(device=token.device)
+                    so_far = torch.cat((so_far, token.view(-1)))
+                    decoded_new = self.decode(so_far)
+                    yield decoded_new[len(decoded_so_far) :]
+                    decoded_so_far = decoded_new
+            except KeyboardInterrupt:
+                return
+        else:
+            raise NotImplementedError(self.backend)

litgpt/utils.py

@@ -0,0 +1,875 @@
+# Copyright Lightning AI. Licensed under the Apache License 2.0, see LICENSE file.
+
+"""Utility functions for training and inference."""
+
+import inspect
+import json
+import math
+import os
+import pickle
+import random
+import re
+import shutil
+import subprocess
+import sys
+import warnings
+from dataclasses import asdict, is_dataclass
+from io import BytesIO
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Literal, Mapping, Optional, TypeVar, Union
+
+import lightning as L
+import psutil
+import torch
+import torch.nn as nn
+import torch.utils._device
+import yaml
+from lightning.fabric.loggers import CSVLogger, TensorBoardLogger
+from lightning.fabric.strategies import FSDPStrategy
+from lightning.fabric.utilities.load import _lazy_load as lazy_load
+from lightning.pytorch.cli import instantiate_class
+from lightning.pytorch.loggers import MLFlowLogger, WandbLogger
+from lightning_utilities.core.imports import module_available
+from packaging import version
+from torch.serialization import normalize_storage_type
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from litgpt import GPT, Config
+
+_THUNDER_AVAILABLE = module_available("thunder")
+_TRITON_AVAILABLE = module_available("triton")
+
+
+def init_out_dir(out_dir: Path) -> Path:
+    if not isinstance(out_dir, Path):
+        out_dir = Path(out_dir)
+    if not out_dir.is_absolute() and "LIGHTNING_ARTIFACTS_DIR" in os.environ:
+        return Path(os.getenv("LIGHTNING_ARTIFACTS_DIR")) / out_dir
+    return out_dir
+
+
+def find_resume_path(resume: Union[bool, Literal["auto"], Path], out_dir: Path) -> Optional[Path]:
+    if not resume or isinstance(resume, Path):
+        return resume
+
+    resume_path = max(out_dir.rglob("step-*/*.pth"), key=(lambda p: int(p.parent.name.split("-")[1])), default=None)
+    if resume == "auto":
+        return resume_path
+    if resume is True and resume_path is None:
+        raise FileNotFoundError(
+            f"You passed `--resume=True`, but no checkpoint file was found in `--out_dir={out_dir}`."
+        )
+    return resume_path
+
+
+def num_parameters(module: nn.Module, requires_grad: Optional[bool] = None) -> int:
+    total = 0
+    for p in module.parameters():
+        if requires_grad is None or p.requires_grad == requires_grad:
+            if hasattr(p, "quant_state"):
+                # bitsandbytes 4bit layer support
+                total += math.prod(p.quant_state.shape)
+            else:
+                total += p.numel()
+    return total
+
+
+def reset_parameters(module: nn.Module) -> None:
+    """Calls `reset_parameters` on the module and all its submodules."""
+    for mod in module.modules():
+        if callable(getattr(mod, "reset_parameters", None)):
+            mod.reset_parameters()
+
+
+def check_valid_checkpoint_dir(
+    checkpoint_dir: Path,
+    model_filename: str = "lit_model.pth",
+    verbose: bool = True,
+    raise_error: bool = False,
+    ignore_tokenizer_files: bool = False,
+) -> None:
+    files = {
+        model_filename: (checkpoint_dir / model_filename).is_file(),
+        "model_config.yaml": (checkpoint_dir / "model_config.yaml").is_file(),
+    }
+    if not ignore_tokenizer_files:
+        files.update(
+            {
+                "tokenizer.json OR tokenizer.model": (checkpoint_dir / "tokenizer.json").is_file()
+                or (checkpoint_dir / "tokenizer.model").is_file(),
+                "tokenizer_config.json": (checkpoint_dir / "tokenizer_config.json").is_file(),
+            }
+        )
+
+    if checkpoint_dir.is_dir():
+        if all(files.values()):
+            # we're good
+            return
+        problem = f" is missing the files: {[f for f, exists in files.items() if not exists]!r}"
+    else:
+        problem = " is not a checkpoint directory"
+
+    # list locally available checkpoints
+    available = list(Path("checkpoints").glob("*/*"))
+    if available:
+        options = "\n".join([""] + [repr(str(p.resolve())) for p in available])
+        extra = f"\nYou have downloaded locally:{options}\n"
+    else:
+        extra = ""
+
+    if verbose:
+        error_message = (
+            f"checkpoint_dir {str(checkpoint_dir.absolute())!r}{problem}."
+            "\nFind download instructions at https://github.com/Lightning-AI/litgpt/blob/main/tutorials\n"
+            f"{extra}\nSee all download options by running:\n litgpt download"
+        )
+        print(error_message, file=sys.stderr)
+
+    if raise_error:
+        raise FileNotFoundError(f"checkpoint_dir {str(checkpoint_dir.absolute())!r}{problem}.")
+    else:
+        raise SystemExit(1)
+
+
+class SavingProxyForStorage:
+    def __init__(self, obj, saver, protocol_version=5):
+        self.protocol_version = protocol_version
+        self.saver = saver
+        if not (isinstance(obj, torch.storage.TypedStorage) or torch.is_storage(obj)):
+            raise TypeError(f"expected storage, not {type(obj)}")
+
+        # this logic is taken from PyTorch 2.0+ torch/serialization.py
+        if isinstance(obj, torch.storage.TypedStorage):
+            # PT upstream wants to deprecate this eventually...
+            storage = obj._untyped_storage
+            storage_type_str = obj._pickle_storage_type()
+            storage_type = getattr(torch, storage_type_str)
+            storage_numel = obj._size()
+        else:
+            storage = obj
+            storage_type = normalize_storage_type(type(obj))
+            storage_numel = storage.nbytes()
+
+        storage_key = saver._write_storage_and_return_key(storage)
+        location = torch.serialization.location_tag(storage)
+
+        self.storage_info = ("storage", storage_type, storage_key, location, storage_numel)
+
+    def __reduce_ex__(self, protocol_version):
+        assert False, "this should be handled with out of band"
+
+
+class SavingProxyForTensor:
+    def __init__(self, tensor, saver, protocol_version=5):
+        self.protocol_version = protocol_version
+        self.reduce_ret_fn, reduce_args = tensor.__reduce_ex__(protocol_version)
+        if reduce_args[0] == torch._utils._rebuild_tensor_v2:
+            # for Tensors with Python attributes
+            (a0, a1, (storage, *a2_other), *other_reduce_args) = reduce_args
+            assert isinstance(storage, (torch.storage.TypedStorage, torch.storage.UntypedStorage)), (
+                "Please check for updates"
+            )
+            storage_proxy = SavingProxyForStorage(storage, saver, protocol_version=protocol_version)
+            self.reduce_args = (a0, a1, (storage_proxy, *a2_other), *other_reduce_args)
+        else:
+            (storage, *other_reduce_args) = reduce_args
+            assert isinstance(storage, (torch.storage.TypedStorage, torch.storage.UntypedStorage)), (
+                "Please check for updates"
+            )
+            storage_proxy = SavingProxyForStorage(storage, saver, protocol_version=protocol_version)
+            self.reduce_args = (storage_proxy, *other_reduce_args)
+
+    def __reduce_ex__(self, protocol_version):
+        if protocol_version != self.protocol_version:
+            raise RuntimeError(f"Unexpected protocol version: expected {self.protocol_version}, got {protocol_version}")
+        return self.reduce_ret_fn, self.reduce_args
+
+
+class IncrementalPyTorchPickler(pickle.Pickler):
+    def __init__(self, saver, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.storage_dtypes = {}
+        self.saver = saver
+        self.id_map = {}
+
+    # this logic is taken from PyTorch 2.0+ torch/serialization.py
+    def persistent_id(self, obj):
+        # FIXME: the docs say that persistent_id should only return a string
+        # but torch store returns tuples. This works only in the binary protocol
+        # see
+        # https://docs.python.org/2/library/pickle.html#pickling-and-unpickling-external-objects
+        # https://github.com/python/cpython/blob/master/Lib/pickle.py#L527-L537
+        if isinstance(obj, SavingProxyForStorage):
+            return obj.storage_info
+
+        if isinstance(obj, torch.storage.TypedStorage) or torch.is_storage(obj):
+            if isinstance(obj, torch.storage.TypedStorage):
+                # TODO: Once we decide to break serialization FC, this case
+                # can be deleted
+                storage = obj._untyped_storage
+                storage_dtype = obj.dtype
+                storage_type_str = obj._pickle_storage_type()
+                storage_type = getattr(torch, storage_type_str)
+                storage_numel = obj._size()
+
+            else:
+                storage = obj
+                storage_dtype = torch.uint8
+                storage_type = normalize_storage_type(type(obj))
+                storage_numel = storage.nbytes()
+
+            # If storage is allocated, ensure that any other saved storages
+            # pointing to the same data all have the same dtype. If storage is
+            # not allocated, don't perform this check
+            if storage.data_ptr() != 0:
+                if storage.data_ptr() in self.storage_dtypes:
+                    if storage_dtype != self.storage_dtypes[storage.data_ptr()]:
+                        raise RuntimeError(
+                            "Cannot save multiple tensors or storages that view the same data as different types"
+                        )
+                else:
+                    self.storage_dtypes[storage.data_ptr()] = storage_dtype
+
+            storage_key = self.id_map.get(storage._cdata)
+            if storage_key is None:
+                storage_key = self.saver._write_storage_and_return_key(storage)
+                self.id_map[storage._cdata] = storage_key
+            location = torch.serialization.location_tag(storage)
+
+            return ("storage", storage_type, storage_key, location, storage_numel)
+
+        return None
+
+
+class incremental_save:
+    def __init__(self, name):
+        self.name = name
+        self.zipfile = torch._C.PyTorchFileWriter(str(name))
+        self.has_saved = False
+        self.next_key = 0
+        self.protocol_version = 2
+
+    def __enter__(self):
+        return self
+
+    def store_early(self, tensor):
+        if isinstance(tensor, torch.Tensor):
+            return SavingProxyForTensor(tensor, self, protocol_version=self.protocol_version)
+        raise TypeError(f"can only store tensors early, not {type(tensor)}")
+
+    def save(self, obj):
+        if self.has_saved:
+            raise RuntimeError("have already saved")
+        # Write the pickle data for `obj`
+        data_buf = BytesIO()
+        pickler = IncrementalPyTorchPickler(self, data_buf, protocol=self.protocol_version)
+        pickler.dump(obj)
+        data_value = data_buf.getvalue()
+        self.zipfile.write_record("data.pkl", data_value, len(data_value))
+        self.has_saved = True
+
+    def _write_storage_and_return_key(self, storage):
+        if self.has_saved:
+            raise RuntimeError("have already saved")
+        key = self.next_key
+        self.next_key += 1
+        name = f"data/{key}"
+        if storage.device.type != "cpu":
+            storage = storage.cpu()
+        num_bytes = storage.nbytes()
+
+        current_version = version.parse(torch.__version__)
+        threshold_version = version.parse("2.2.2")
+        if current_version <= threshold_version:
+            self.zipfile.write_record(name, storage.data_ptr(), num_bytes)
+        else:
+            self.zipfile.write_record(name, storage, num_bytes)
+
+        return key
+
+    def __exit__(self, type, value, traceback):
+        self.zipfile.write_end_of_file()
+
+
+T = TypeVar("T")
+
+
+def chunked_cross_entropy(
+    logits: Union[torch.Tensor, List[torch.Tensor]],
+    targets: torch.Tensor,
+    chunk_size: int = 128,
+    ignore_index: int = -100,
+) -> torch.Tensor:
+    # with large max_sequence_lengths, the beginning of `backward` allocates a large memory chunk which can dominate
+    # the memory usage in fine-tuning settings with low number of parameters.
+    # as a workaround hack, the cross entropy computation is chunked to force it to deallocate on the go, reducing
+    # the memory spike's magnitude
+
+    # lm_head was chunked (we are fine-tuning)
+    if isinstance(logits, list):
+        # don't want to chunk cross entropy
+        if chunk_size == 0:
+            logits = torch.cat(logits, dim=1)
+            logits = logits.reshape(-1, logits.size(-1))
+            targets = targets.reshape(-1)
+            return torch.nn.functional.cross_entropy(logits, targets, ignore_index=ignore_index)
+
+        # chunk cross entropy
+        logit_chunks = [logit_chunk.reshape(-1, logit_chunk.size(-1)) for logit_chunk in logits]
+        target_chunks = [target_chunk.reshape(-1) for target_chunk in targets.split(logits[0].size(1), dim=1)]
+        loss_chunks = [
+            torch.nn.functional.cross_entropy(logit_chunk, target_chunk, ignore_index=ignore_index, reduction="none")
+            for logit_chunk, target_chunk in zip(logit_chunks, target_chunks)
+        ]
+        non_masked_elems = (targets != ignore_index).sum()
+        # See [non_masked_elems div note]
+        return torch.cat(loss_chunks).sum() / non_masked_elems.maximum(torch.ones_like(non_masked_elems))
+
+    # no chunking at all
+    logits = logits.reshape(-1, logits.size(-1))
+    targets = targets.reshape(-1)
+    if chunk_size == 0:
+        return torch.nn.functional.cross_entropy(logits, targets, ignore_index=ignore_index)
+
+    # lm_head wasn't chunked, chunk cross entropy
+    logit_chunks = logits.split(chunk_size)
+    target_chunks = targets.split(chunk_size)
+    loss_chunks = [
+        torch.nn.functional.cross_entropy(logit_chunk, target_chunk, ignore_index=ignore_index, reduction="none")
+        for logit_chunk, target_chunk in zip(logit_chunks, target_chunks)
+    ]
+    non_masked_elems = (targets != ignore_index).sum()
+    # [non_masked_elems div note]:
+    #   max(1, non_masked_elems) would be more ergonomic to avoid a division by zero. However that
+    #   results in a python int which is then passed back to torch division. By using the
+    #   `x.maximum(torch.ones_like(x))` pattern we avoid a cudaStreamSynchronize.
+    return torch.cat(loss_chunks).sum() / non_masked_elems.maximum(torch.ones_like(non_masked_elems))
+
+
+def map_old_state_dict_weights(state_dict: Dict, mapping: Mapping, prefix: str) -> Dict:
+    for checkpoint_name, attribute_name in mapping.items():
+        full_checkpoint_name = prefix + checkpoint_name
+        if full_checkpoint_name in state_dict:
+            full_attribute_name = prefix + attribute_name
+            state_dict[full_attribute_name] = state_dict.pop(full_checkpoint_name)
+    return state_dict
+
+
+def get_default_supported_precision(training: bool) -> str:
+    """
+    Return the default precision that is supported by the hardware: either `bf16` or `16`.
+
+    Args:
+        training: If True, returns '-mixed' version of the precision; if False, returns '-true' version.
+
+    Returns:
+        The default precision that is suitable for the task and is supported by the hardware.
+    """
+    import torch
+
+    if torch.cuda.is_available():
+        if torch.cuda.is_bf16_supported():
+            return "bf16-mixed" if training else "bf16-true"
+        else:
+            return "16-mixed" if training else "16-true"
+    return "bf16-mixed" if training else "bf16-true"
+
+
+def load_checkpoint(fabric: L.Fabric, model: nn.Module, checkpoint_path: Path, strict: bool = True) -> None:
+    if isinstance(fabric.strategy, FSDPStrategy):
+        fabric.load_raw(checkpoint_path, model, strict=strict)
+    else:
+        state_dict = lazy_load(checkpoint_path)
+        state_dict = state_dict.get("model", state_dict)
+        model.load_state_dict(state_dict, strict=strict)
+
+
+def load_checkpoint_update(
+    fabric: L.Fabric, adapter_path: Path, model: nn.Module, checkpoint_path: Path, strict: bool = True
+) -> None:
+    if isinstance(fabric.strategy, FSDPStrategy):
+        fabric.load_raw(checkpoint_path, model, strict=strict)
+    else:
+        state_dict = lazy_load(checkpoint_path)
+        state_dict = state_dict.get("model", state_dict)
+        adapter_cp = lazy_load(adapter_path)
+        state_dict.update(adapter_cp)
+        model.load_state_dict(state_dict, strict=strict)
+
+
+def flops_per_param(max_seq_length: int, n_layer: int, n_embd: int, n_params: int) -> int:
+    flops_per_token = 2 * n_params  # each parameter is used for a MAC (2 FLOPS) per network operation
+    # this assumes that all samples have a fixed length equal to the block size
+    # which is most likely false during finetuning
+    flops_per_seq = flops_per_token * max_seq_length
+    attn_flops_per_seq = n_layer * 2 * 2 * (n_embd * (max_seq_length**2))
+    return flops_per_seq + attn_flops_per_seq
+
+
+def estimate_flops(model: "GPT", training: bool) -> int:
+    """Measures estimated FLOPs for MFU.
+
+    Refs:
+        * https://ar5iv.labs.arxiv.org/html/2205.05198#A1
+        * https://ar5iv.labs.arxiv.org/html/2204.02311#A2
+    """
+    # using all parameters for this is a naive over estimation because not all model parameters actually contribute to
+    # this FLOP computation (e.g. embedding, norm). For this reason, the result will be higher by a fixed percentage
+    # (~10%) compared to the measured FLOPs, making those lower but more realistic.
+    # For a proper estimate, this needs a more fine-grained calculation as in Appendix A of the paper.
+    n_trainable_params = num_parameters(model, requires_grad=True)
+    trainable_flops = flops_per_param(
+        model.max_seq_length, model.config.n_layer, model.config.n_embd, n_trainable_params
+    )
+    # forward + backward + gradients (assumes no gradient accumulation)
+    ops_per_step = 3 if training else 1
+    n_frozen_params = num_parameters(model, requires_grad=False)
+    frozen_flops = flops_per_param(model.max_seq_length, model.config.n_layer, model.config.n_embd, n_frozen_params)
+    # forward + backward
+    frozen_ops_per_step = 2 if training else 1
+    return ops_per_step * trainable_flops + frozen_ops_per_step * frozen_flops
+
+
+class CycleIterator:
+    """An iterator that cycles through an iterable indefinitely.
+
+    Example:
+        >>> iterator = CycleIterator([1, 2, 3])
+        >>> [next(iterator) for _ in range(5)]
+        [1, 2, 3, 1, 2]
+
+    Note:
+        Unlike ``itertools.cycle``, this iterator does not cache the values of the iterable.
+    """
+
+    def __init__(self, iterable: Iterable) -> None:
+        self.iterable = iterable
+        self.epoch = 0
+        self._iterator = None
+
+    def __next__(self) -> Any:
+        if self._iterator is None:
+            self._iterator = iter(self.iterable)
+        try:
+            return next(self._iterator)
+        except StopIteration:
+            self._iterator = iter(self.iterable)
+            self.epoch += 1
+            return next(self._iterator)
+
+    def __iter__(self) -> Self:
+        return self
+
+
+def copy_config_files(source_dir: Path, out_dir: Path) -> None:
+    """Copies the specified configuration and tokenizer files into the output directory."""
+
+    config_files = ["config.json", "generation_config.json", "model_config.yaml"]
+    tokenizer_files = ["tokenizer.json", "tokenizer.model", "tokenizer_config.json"]
+
+    for file_name in config_files + tokenizer_files:
+        src_path = source_dir / file_name
+        if src_path.exists():
+            shutil.copy(src_path, out_dir)
+
+
+def CLI(*args: Any, **kwargs: Any) -> Any:
+    from jsonargparse import CLI, set_config_read_mode, set_docstring_parse_options
+
+    set_docstring_parse_options(attribute_docstrings=True)
+    set_config_read_mode(urls_enabled=True)
+
+    return CLI(*args, **kwargs)
+
+
+def capture_hparams() -> Dict[str, Any]:
+    """Captures the local variables ('hyperparameters') from where this function gets called."""
+    caller_frame = inspect.currentframe().f_back
+    locals_of_caller = caller_frame.f_locals
+    hparams = {}
+    for name, value in locals_of_caller.items():
+        if value is None or isinstance(value, (int, float, str, bool, Path)):
+            hparams[name] = value
+        elif is_dataclass(value):
+            hparams[name] = asdict(value)
+        else:
+            hparams[name] = str(value)
+    return hparams
+
+
+def save_hyperparameters(function: callable, checkpoint_dir: Path) -> None:
+    """Captures the CLI parameters passed to `function` without running `function` and saves them to the checkpoint."""
+    from jsonargparse import capture_parser
+
+    # TODO: Make this more robust
+    # This hack strips away the subcommands from the top-level CLI
+    # to parse the file as if it was called as a script
+    known_commands = [
+        ("finetune_full",),  # For subcommands, use `("finetune", "full")` etc
+        ("finetune_lora",),
+        ("finetune_adapter",),
+        ("finetune_adapter_v2",),
+        ("finetune",),
+        ("pretrain",),
+    ]
+    for known_command in known_commands:
+        unwanted = slice(1, 1 + len(known_command))
+        if tuple(sys.argv[unwanted]) == known_command:
+            sys.argv[unwanted] = []
+
+    parser = capture_parser(lambda: CLI(function))
+    config = parser.parse_args()
+    parser.save(config, checkpoint_dir / "hyperparameters.yaml", overwrite=True)
+
+
+def save_config(config: "Config", checkpoint_dir: Path) -> None:
+    config_dict = asdict(config)
+    with open(checkpoint_dir / "model_config.yaml", "w", encoding="utf-8") as fp:
+        yaml.dump(config_dict, fp)
+
+
+def parse_devices(devices: Union[str, int]) -> int:
+    if devices in (-1, "auto"):
+        return torch.cuda.device_count() or 1
+    if isinstance(devices, int) and devices > 0:
+        return devices
+    raise ValueError(f"Devices must be 'auto' or a positive integer, got: {devices!r}")
+
+
+def choose_logger(
+    logger_name: Literal["csv", "tensorboard", "wandb", "mlflow"],
+    out_dir: Path,
+    name: str,
+    log_interval: int = 1,
+    log_args: Optional[Dict] = None,
+    resume: Optional[bool] = None,
+    **kwargs: Any,
+):
+    if logger_name == "csv":
+        return CSVLogger(root_dir=(out_dir / "logs"), name="csv", flush_logs_every_n_steps=log_interval, **kwargs)
+    if logger_name == "tensorboard":
+        return TensorBoardLogger(root_dir=(out_dir / "logs"), name="tensorboard", **kwargs)
+    if logger_name == "wandb":
+        project = log_args.pop("project", name)
+        run = log_args.pop("run", os.environ.get("WANDB_RUN_NAME"))
+        group = log_args.pop("group", os.environ.get("WANDB_RUN_GROUP"))
+        return WandbLogger(project=project, name=run, group=group, resume=resume, **kwargs)
+    if logger_name == "mlflow":
+        return MLFlowLogger(experiment_name=name, **kwargs)
+    raise ValueError(f"`--logger_name={logger_name}` is not a valid option. Choose from 'csv', 'tensorboard', 'wandb'.")
+
+
+def get_argument_names(cls):
+    sig = inspect.signature(cls.__init__)
+    return {
+        name
+        for name, param in sig.parameters.items()
+        if param.kind in [inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY]
+    }
+
+
+def instantiate_bnb_optimizer(optimizer, model_parameters):
+    if (isinstance(optimizer, str) and "AdamW" not in optimizer) or (
+        isinstance(optimizer, dict) and "AdamW" not in optimizer.get("class_path", "")
+    ):
+        raise ValueError("The chosen quantization format only supports the AdamW optimizer.")
+
+    import bitsandbytes as bnb
+
+    if isinstance(optimizer, str):
+        optimizer = bnb.optim.PagedAdamW(model_parameters)
+    else:
+        optim_args = get_argument_names(bnb.optim.PagedAdamW)
+        allowed_kwargs = {key: optimizer["init_args"][key] for key in optim_args & optimizer["init_args"].keys()}
+        optimizer = bnb.optim.PagedAdamW(model_parameters, **allowed_kwargs)
+    return optimizer
+
+
+def instantiate_torch_optimizer(optimizer, model_parameters, **kwargs):
+    # Special care taken where some optimizers do not have some parameters referenced in some of the code, for example "fused" in the pretrain.py script:
+    #   bnb.optim.AdamW8bit
+    #   grokadamw.GrokAdamW
+    #   torch.optim.RMSprop
+
+    if isinstance(optimizer, str):
+        if "." in optimizer:
+            class_module, class_name = optimizer.rsplit(".", 1)
+        else:
+            class_module, class_name = "torch.optim", optimizer
+
+        module = __import__(class_module, fromlist=[class_name])
+        optimizer_cls = getattr(module, class_name)
+
+        valid_params = set(inspect.signature(optimizer_cls).parameters)
+        kwargs = {key: value for key, value in dict(kwargs).items() if key in valid_params}
+        optimizer = optimizer_cls(model_parameters, **kwargs)
+    elif isinstance(optimizer, dict):
+        optimizer = dict(optimizer)
+        class_module, class_name = optimizer["class_path"].rsplit(".", 1)
+        module = __import__(class_module, fromlist=[class_name])
+        optimizer_cls = getattr(module, class_name)
+
+        valid_params = set(inspect.signature(optimizer_cls).parameters)
+        kwargs = {key: value for key, value in dict(kwargs).items() if key in valid_params}
+
+        optimizer["init_args"].update(kwargs)
+        optimizer = instantiate_class(model_parameters, optimizer)
+    else:
+        raise ValueError(f'Unrecognized "optimizer" value: {optimizer}')
+
+    return optimizer
+
+
+def extend_checkpoint_dir(checkpoint_dir: Path) -> Path:
+    new_checkpoint_dir = "checkpoints" / checkpoint_dir
+    should_return_new_dir = (
+        not checkpoint_dir.is_dir()
+        and checkpoint_dir.parts[0] != "checkpoints"
+        and not checkpoint_dir.is_absolute()
+        and new_checkpoint_dir.exists()
+    )
+    return new_checkpoint_dir if should_return_new_dir else checkpoint_dir
+
+
+def check_file_size_on_cpu_and_warn(checkpoint_path, device, size_limit=4_509_715_660):
+    """
+    Checks the file size and raises a warning if it exceeds the size_limit.
+    The default size limit is 4.2 GB, the size of TinyLlama 1.1B: 4.2 * 1024 * 1024 * 1024 = 4_509_715_660
+    """
+    size = 0.0
+    if os.path.exists(checkpoint_path):
+        size = os.path.getsize(checkpoint_path)
+        if size > size_limit and str(device) == "cpu":
+            warnings.warn(
+                f"The file size of {checkpoint_path} is over {size_limit / 1024 / 1024 / 1024:.1f} GB. Using a model "
+                "with more than 1B parameters on a CPU can be slow, it is recommended to switch to a GPU."
+            )
+    return size
+
+
+def auto_download_checkpoint(model_name, access_token=None, ignore_tokenizer_files=False):
+    from litgpt.scripts.download import download_from_hub  # moved here due to circular import issue
+
+    checkpoint_dir = extend_checkpoint_dir(Path(model_name))
+    try:
+        check_valid_checkpoint_dir(
+            checkpoint_dir, verbose=False, raise_error=True, ignore_tokenizer_files=ignore_tokenizer_files
+        )
+    except FileNotFoundError as e:
+        if access_token is None:
+            access_token = os.getenv("HF_TOKEN")
+
+        if checkpoint_dir.parts[0] != "checkpoints" and not checkpoint_dir.is_absolute():
+            download_from_hub(repo_id=str(model_name), access_token=access_token)
+            checkpoint_dir = Path("checkpoints") / checkpoint_dir
+        else:
+            raise e
+
+    return checkpoint_dir
+
+
+def check_nvlink_connectivity(fabric=None):
+    """Checks GPU connectivity for both NVIDIA and AMD GPUs.
+
+    This function delegates to vendor-specific implementations based on
+    the detected GPU vendor.
+    """
+    if fabric is not None:
+        custom_print = fabric.print
+    else:
+        custom_print = print
+
+    if os.getenv("RANK", "0") == "0":
+        try:
+            if torch.cuda.is_available():
+                device_properties = torch.cuda.get_device_properties(0)
+                gpu_name = device_properties.name.lower()
+                if "nvidia" in gpu_name:
+                    _check_nvidia_connectivity(custom_print)
+                elif "advanced micro devices" in gpu_name or "amd" in gpu_name:
+                    _check_amd_connectivity(custom_print)
+                else:
+                    custom_print(f"Unrecognized GPU vendor: {device_properties.name}")
+            else:
+                custom_print("No GPUs available")
+        except Exception as e:
+            custom_print(f"An error occurred while checking GPU connectivity: {e}")
+
+
+def _check_nvidia_connectivity(custom_print):
+    """Checks NVLink connectivity on NVIDIA GPUs."""
+    result = subprocess.run(["nvidia-smi", "topo", "-m"], stdout=subprocess.PIPE, text=True)
+    if result.returncode != 0:
+        custom_print("Failed to run nvidia-smi")
+        return
+
+    lines = result.stdout.strip().split("\n")
+    start_index = next((i for i, line in enumerate(lines) if "GPU0" in line), None)
+    if start_index is None:
+        custom_print("Failed to parse nvidia-smi output")
+        return
+
+    headers_line = lines[start_index]
+    headers = headers_line.split()
+    gpu_regex = re.compile(r"^GPU\d+$")
+    gpu_count = len([header for header in headers if gpu_regex.match(header)])
+
+    all_nvlink = True
+    for line in lines[start_index + 1 : start_index + 1 + gpu_count]:
+        columns = line.split()
+        connections = columns[1 : 1 + gpu_count]
+        if not all("NV" in conn for conn in connections if conn != "X"):
+            all_nvlink = False
+            break
+
+    if all_nvlink:
+        custom_print("All GPUs are fully connected via NVLink.")
+    else:
+        custom_print(
+            "Warning: Not all GPUs are fully connected via NVLink. Some GPUs are connected via slower interfaces. "
+            "It is recommended to switch to a different machine with faster GPU connections for optimal multi-GPU training performance."
+        )
+
+
+def _check_amd_connectivity(custom_print):
+    """Checks XGMI connectivity on AMD GPUs."""
+    result = subprocess.run(["rocm-smi", "--showtopotype"], stdout=subprocess.PIPE, text=True)
+    if result.returncode != 0:
+        custom_print("Failed to run rocm-smi")
+        return
+
+    lines = result.stdout.strip().split("\n")
+    gpu_header_index = next((i for i, line in enumerate(lines) if re.match(r"^\s*GPU0", line)), None)
+    if gpu_header_index is None or gpu_header_index == 0:
+        custom_print("Failed to parse rocm-smi output (no GPU headers found)")
+        return
+
+    header_line = lines[gpu_header_index - 1]
+    headers = header_line.strip().split()
+    gpu_regex = re.compile(r"^GPU\d+$")
+    gpu_count = len([header for header in headers if gpu_regex.match(header)])
+
+    gpu_lines = []
+    for line in lines[gpu_header_index : gpu_header_index + gpu_count]:
+        if re.match(r"^\s*GPU\d+", line):
+            gpu_lines.append(line.strip())
+    if len(gpu_lines) != gpu_count:
+        custom_print("Mismatch in GPU count when parsing rocm-smi output")
+        return
+
+    all_xgmi = True
+    for line in gpu_lines:
+        columns = line.split()
+        connections = columns[1 : 1 + gpu_count]
+        for conn in connections:
+            if conn not in ("XGMI", "0"):
+                all_xgmi = False
+                break
+        if not all_xgmi:
+            break
+
+    if all_xgmi:
+        custom_print("All GPUs are fully connected via XGMI.")
+    else:
+        custom_print(
+            "Warning: Not all GPUs are fully connected via XGMI. Some GPUs are connected via slower interfaces. "
+            "It is recommended to switch to a different machine with faster GPU connections for optimal multi-GPU training performance."
+        )
+
+
+def fix_and_load_json(s):
+    # Remove trailing commas before } or ]
+    s = re.sub(r",(\s*[}\]])", r"\1", s)
+
+    # Insert missing commas between properties
+    # Match positions where a value is followed by a newline and then a quote without a comma
+    pattern = r'(?<=[}\]0-9truefalsenull"])\s*(\n\s*)"'
+    replacement = r',\1"'
+    s = re.sub(pattern, replacement, s)
+
+    # Now try to parse the JSON
+    try:
+        return json.loads(s)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Failed to parse JSON after fixing: {e}")
+
+
+def create_finetuning_performance_report(training_time, token_counts, device_type):
+    tok_sec = token_counts["raw_tokens_plus_prompt_template_and_padding"] / training_time
+    output = f"""
+| ------------------------------------------------------
+| Token Counts
+| - Input Tokens              :  {token_counts["raw_tokens"]:>5}
+| - Tokens w/ Prompt          :  {token_counts["raw_tokens_plus_prompt_template"]:>5}
+| - Total Tokens (w/ Padding) :  {token_counts["raw_tokens_plus_prompt_template_and_padding"]:>5}
+| -----------------------------------------------------
+| Performance
+| - Training Time             :  {training_time:.2f} s
+| - Tok/sec                   :  {tok_sec:.2f} tok/s
+| -----------------------------------------------------
+"""
+
+    if device_type == "cuda":
+        memory_used = torch.cuda.max_memory_allocated() / 1e9
+        output += "| Memory Usage                                                                 \n"
+        output += f"| - Memory Used               :  {memory_used:.02f} GB                                        \n"
+    output += "-------------------------------------------------------\n"
+
+    return output
+
+
+def select_sft_generate_example(eval, data):
+    if eval.evaluate_example == "first":
+        if len(data.test_dataset.data):
+            instruction = data.test_dataset.data[0]["instruction"]
+        else:
+            instruction = data.train_dataset.data[0]["instruction"]
+
+    elif eval.evaluate_example == "random":
+        if len(data.test_dataset.data):
+            random_idx = random.randint(0, len(data.test_dataset.data) - 1)
+            instruction = data.test_dataset.data[random_idx]["instruction"]
+        else:
+            random_idx = random.randint(0, len(data.train_dataset.data) - 1)
+            instruction = data.train_dataset.data[random_idx]["instruction"]
+
+    elif isinstance(eval.evaluate_example, int):
+        index = eval.evaluate_example
+        if len(data.test_dataset.data) > index:
+            instruction = data.test_dataset.data[index]["instruction"]
+        elif len(data.train_dataset.data) > index:
+            instruction = data.train_dataset.data[index]["instruction"]
+        else:
+            raise IndexError(f"Index {index} is out of range for both test and training datasets.")
+
+    else:
+        raise ValueError(f"Unknown evaluation example type: {eval.evaluate_example}")
+    return instruction
+
+
+def _RunIf(thunder: bool = False, **kwargs):
+    import pytest
+    from lightning.fabric.utilities.testing import _runif_reasons
+
+    reasons, marker_kwargs = _runif_reasons(**kwargs)
+
+    if thunder and not module_available("thunder"):
+        # if we require Thunder, but it's not available, we should skip
+        reasons.append("Thunder")
+
+    return pytest.mark.skipif(condition=len(reasons) > 0, reason=f"Requires: [{' + '.join(reasons)}]", **marker_kwargs)
+
+
+def kill_process_tree(pid: int):
+    """
+    Kill a process and all its child processes given the parent PID.
+    """
+    try:
+        parent = psutil.Process(pid)
+        children = parent.children(recursive=True)
+        for child in children:
+            child.kill()
+        parent.kill()
+    except psutil.NoSuchProcess:
+        pass  # Process already exited

out/eval/tinyllama_benches/monthly_metrics.csv

@@ -0,0 +1,133 @@
+month,task,metric,value
+2407,arc_challenge,acc,0.26621160409556316
+2408,arc_challenge,acc,0.25426621160409557
+2409,arc_challenge,acc,0.23890784982935154
+2410,arc_challenge,acc,0.24146757679180889
+2411,arc_challenge,acc,0.2380546075085324
+2412,arc_challenge,acc,0.23464163822525597
+2501,arc_challenge,acc,0.22525597269624573
+2502,arc_challenge,acc,0.21928327645051193
+2503,arc_challenge,acc,0.22013651877133106
+2504,arc_challenge,acc,0.22781569965870307
+2505,arc_challenge,acc,0.2175767918088737
+2506,arc_challenge,acc,0.23976109215017063
+2407,arc_challenge,acc_norm,0.3046075085324232
+2408,arc_challenge,acc_norm,0.2883959044368601
+2409,arc_challenge,acc_norm,0.2764505119453925
+2410,arc_challenge,acc_norm,0.26535836177474403
+2411,arc_challenge,acc_norm,0.27047781569965873
+2412,arc_challenge,acc_norm,0.25170648464163825
+2501,arc_challenge,acc_norm,0.2568259385665529
+2502,arc_challenge,acc_norm,0.24061433447098976
+2503,arc_challenge,acc_norm,0.26023890784982934
+2504,arc_challenge,acc_norm,0.24829351535836178
+2505,arc_challenge,acc_norm,0.26535836177474403
+2506,arc_challenge,acc_norm,0.2687713310580205
+2407,arc_easy,acc,0.5757575757575758
+2408,arc_easy,acc,0.5391414141414141
+2409,arc_easy,acc,0.5260942760942761
+2410,arc_easy,acc,0.5244107744107744
+2411,arc_easy,acc,0.5071548821548821
+2412,arc_easy,acc,0.48569023569023567
+2501,arc_easy,acc,0.4941077441077441
+2502,arc_easy,acc,0.47095959595959597
+2503,arc_easy,acc,0.4852693602693603
+2504,arc_easy,acc,0.4659090909090909
+2505,arc_easy,acc,0.4722222222222222
+2506,arc_easy,acc,0.47769360269360267
+2407,arc_easy,acc_norm,0.531986531986532
+2408,arc_easy,acc_norm,0.5004208754208754
+2409,arc_easy,acc_norm,0.49957912457912457
+2410,arc_easy,acc_norm,0.49326599326599324
+2411,arc_easy,acc_norm,0.4819023569023569
+2412,arc_easy,acc_norm,0.4511784511784512
+2501,arc_easy,acc_norm,0.4583333333333333
+2502,arc_easy,acc_norm,0.4318181818181818
+2503,arc_easy,acc_norm,0.4537037037037037
+2504,arc_easy,acc_norm,0.44023569023569026
+2505,arc_easy,acc_norm,0.44191919191919193
+2506,arc_easy,acc_norm,0.45664983164983164
+2407,hellaswag,acc,0.416849233220474
+2408,hellaswag,acc,0.3974307906791476
+2409,hellaswag,acc,0.38498307110137425
+2410,hellaswag,acc,0.3686516630153356
+2411,hellaswag,acc,0.35610436168094006
+2412,hellaswag,acc,0.3496315475004979
+2501,hellaswag,acc,0.34405496912965544
+2502,hellaswag,acc,0.33409679346743676
+2503,hellaswag,acc,0.33738299143596895
+2504,hellaswag,acc,0.3301135232025493
+2505,hellaswag,acc,0.3280223063134834
+2506,hellaswag,acc,0.3253335988846843
+2407,hellaswag,acc_norm,0.5473013343955387
+2408,hellaswag,acc_norm,0.5153355905198168
+2409,hellaswag,acc_norm,0.489344752041426
+2410,hellaswag,acc_norm,0.46484763991236805
+2411,hellaswag,acc_norm,0.44343756223859787
+2412,hellaswag,acc_norm,0.4257120095598486
+2501,hellaswag,acc_norm,0.4239195379406493
+2502,hellaswag,acc_norm,0.4017128062139016
+2503,hellaswag,acc_norm,0.40201155148376816
+2504,hellaswag,acc_norm,0.39543915554670384
+2505,hellaswag,acc_norm,0.3903604859589723
+2506,hellaswag,acc_norm,0.38697470623381797
+2407,mmlu,acc,0.241917105825381
+2408,mmlu,acc,0.2318758011679248
+2409,mmlu,acc,0.22959692351516878
+2410,mmlu,acc,0.23807149978635522
+2411,mmlu,acc,0.23508047286711295
+2412,mmlu,acc,0.2352229027204102
+2501,mmlu,acc,0.2380002848597066
+2502,mmlu,acc,0.23593505198689646
+2503,mmlu,acc,0.2318758011679248
+2504,mmlu,acc,0.23251673550776242
+2505,mmlu,acc,0.23678963110667997
+2506,mmlu,acc,0.24291411479846176
+2407,sciq,acc,0.882
+2408,sciq,acc,0.87
+2409,sciq,acc,0.882
+2410,sciq,acc,0.866
+2411,sciq,acc,0.857
+2412,sciq,acc,0.855
+2501,sciq,acc,0.854
+2502,sciq,acc,0.836
+2503,sciq,acc,0.82
+2504,sciq,acc,0.833
+2505,sciq,acc,0.834
+2506,sciq,acc,0.847
+2407,sciq,acc_norm,0.844
+2408,sciq,acc_norm,0.804
+2409,sciq,acc_norm,0.819
+2410,sciq,acc_norm,0.811
+2411,sciq,acc_norm,0.822
+2412,sciq,acc_norm,0.811
+2501,sciq,acc_norm,0.802
+2502,sciq,acc_norm,0.781
+2503,sciq,acc_norm,0.771
+2504,sciq,acc_norm,0.778
+2505,sciq,acc_norm,0.786
+2506,sciq,acc_norm,0.795
+2407,truthfulqa_mc1,acc,0.2423500611995104
+2408,truthfulqa_mc1,acc,0.2594859241126071
+2409,truthfulqa_mc1,acc,0.2386780905752754
+2410,truthfulqa_mc1,acc,0.2521419828641371
+2411,truthfulqa_mc1,acc,0.2607099143206854
+2412,truthfulqa_mc1,acc,0.26805385556915545
+2501,truthfulqa_mc1,acc,0.27906976744186046
+2502,truthfulqa_mc1,acc,0.2974296205630355
+2503,truthfulqa_mc1,acc,0.26193390452876375
+2504,truthfulqa_mc1,acc,0.27050183598531213
+2505,truthfulqa_mc1,acc,0.26438188494492043
+2506,truthfulqa_mc1,acc,0.26805385556915545
+2407,truthfulqa_mc2,acc,0.41171296428698934
+2408,truthfulqa_mc2,acc,0.4127800755882328
+2409,truthfulqa_mc2,acc,0.40520433625245705
+2410,truthfulqa_mc2,acc,0.42608784023385377
+2411,truthfulqa_mc2,acc,0.42431987710612645
+2412,truthfulqa_mc2,acc,0.426638224947852
+2501,truthfulqa_mc2,acc,0.43294939737693783
+2502,truthfulqa_mc2,acc,0.45673716541282944
+2503,truthfulqa_mc2,acc,0.4308698731928784
+2504,truthfulqa_mc2,acc,0.4490762477503484
+2505,truthfulqa_mc2,acc,0.43051964732093856
+2506,truthfulqa_mc2,acc,0.4367369684704035

out/eval/tinyllama_full_arc_arxiv_mc/2407/config.json

@@ -0,0 +1,24 @@
+{
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "hidden_act": "silu",
+  "hidden_size": 2048,
+  "initializer_range": 0.02,
+  "intermediate_size": 5632,
+  "max_position_embeddings": 2048,
+  "model_type": "llama",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 22,
+  "num_key_value_heads": 4,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": null,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float32",
+  "transformers_version": "4.31.0.dev0",
+  "use_cache": true,
+  "vocab_size": 32000
+}

out/eval/tinyllama_full_arc_arxiv_mc/2407/generation_config.json

@@ -0,0 +1,7 @@
+{
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "pad_token_id": 0,
+  "max_length": 2048,
+  "transformers_version": "4.31.0.dev0"
+}

out/eval/tinyllama_full_arc_arxiv_mc/2407/log.txt

@@ -0,0 +1,29 @@
+{'access_token': None,
+ 'batch_size': 4,
+ 'checkpoint_dir': PosixPath('out/finetune/tinyllama_full_arc/2407/final'),
+ 'device': None,
+ 'dtype': None,
+ 'force_conversion': False,
+ 'limit': None,
+ 'num_fewshot': None,
+ 'out_dir': PosixPath('out/eval/tinyllama_full_arc_arxiv_mc/2407'),
+ 'save_filepath': None,
+ 'seed': 1234,
+ 'tasks': 'arxiv_mc'}
+INFO 09-24 14:45:19 [__init__.py:241] Automatically detected platform cuda.
+Detected kernel version 5.4.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.
+{'checkpoint_dir': PosixPath('out/finetune/tinyllama_full_arc/2407/final'),
+ 'output_dir': PosixPath('out/eval/tinyllama_full_arc_arxiv_mc/2407')}
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+
  0%|          | 0/100 [00:00<?, ?it/s]
+

out/eval/tinyllama_full_arc_arxiv_mc/2407/model_config.yaml

@@ -0,0 +1,44 @@
+attention_logit_softcapping: null
+attention_scores_scalar: null
+attn_bias: false
+bias: false
+block_size: 2048
+final_logit_softcapping: null
+gelu_approximate: none
+head_size: 64
+hf_config:
+  name: TinyLlama-1.1B-intermediate-step-1431k-3T
+  org: TinyLlama
+intermediate_size: 5632
+lm_head_bias: false
+mlp_class_name: LLaMAMLP
+moe_intermediate_size: null
+n_embd: 2048
+n_expert: 0
+n_expert_per_token: 0
+n_head: 32
+n_layer: 22
+n_query_groups: 4
+name: tiny-llama-1.1b
+norm_1: true
+norm_2: true
+norm_class_name: RMSNorm
+norm_eps: 1.0e-05
+norm_qk: false
+norm_qk_type: default
+padded_vocab_size: 32000
+padding_multiple: 64
+parallel_residual: false
+post_attention_norm: false
+post_mlp_norm: false
+rope_adjustments: null
+rope_base: 10000
+rope_condense_ratio: 1
+rope_indices: null
+rope_local_base_freq: null
+rotary_percentage: 1.0
+scale_embeddings: false
+shared_attention_norm: false
+sliding_window_indices: null
+sliding_window_size: null
+vocab_size: 32000

out/eval/tinyllama_full_arc_arxiv_mc/2407/tokenizer_config.json

@@ -0,0 +1,35 @@
+{
+  "add_bos_token": true,
+  "add_eos_token": false,
+  "bos_token": {
+    "__type": "AddedToken",
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "clean_up_tokenization_spaces": false,
+  "eos_token": {
+    "__type": "AddedToken",
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "legacy": false,
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": null,
+  "padding_side": "right",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "LlamaTokenizer",
+  "unk_token": {
+    "__type": "AddedToken",
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

out/eval/tinyllama_full_arc_arxiv_mc/2407/values.json

@@ -0,0 +1,286 @@
+{
+  "tasks": [
+    {
+      "task": "arxiv_mc",
+      "metric": "acc",
+      "value": 0.16583333333333333
+    },
+    {
+      "task": "arxiv_mc",
+      "metric": "acc_stderr",
+      "value": 0.01074491240245708
+    },
+    {
+      "task": "arxiv_mc",
+      "metric": "acc_norm",
+      "value": 0.23916666666666667
+    },
+    {
+      "task": "arxiv_mc",
+      "metric": "acc_norm_stderr",
+      "value": 0.012288331311441483
+    },
+    {
+      "task": "arxiv_mc_2407",
+      "metric": "acc",
+      "value": 0.2
+    },
+    {
+      "task": "arxiv_mc_2407",
+      "metric": "acc_stderr",
+      "value": 0.04020151261036846
+    },
+    {
+      "task": "arxiv_mc_2407",
+      "metric": "acc_norm",
+      "value": 0.33
+    },
+    {
+      "task": "arxiv_mc_2407",
+      "metric": "acc_norm_stderr",
+      "value": 0.047258156262526045
+    },
+    {
+      "task": "arxiv_mc_2408",
+      "metric": "acc",
+      "value": 0.16
+    },
+    {
+      "task": "arxiv_mc_2408",
+      "metric": "acc_stderr",
+      "value": 0.036845294917747115
+    },
+    {
+      "task": "arxiv_mc_2408",
+      "metric": "acc_norm",
+      "value": 0.18
+    },
+    {
+      "task": "arxiv_mc_2408",
+      "metric": "acc_norm_stderr",
+      "value": 0.03861229196653697
+    },
+    {
+      "task": "arxiv_mc_2409",
+      "metric": "acc",
+      "value": 0.14
+    },
+    {
+      "task": "arxiv_mc_2409",
+      "metric": "acc_stderr",
+      "value": 0.03487350880197772
+    },
+    {
+      "task": "arxiv_mc_2409",
+      "metric": "acc_norm",
+      "value": 0.24
+    },
+    {
+      "task": "arxiv_mc_2409",
+      "metric": "acc_norm_stderr",
+      "value": 0.04292346959909283
+    },
+    {
+      "task": "arxiv_mc_2410",
+      "metric": "acc",
+      "value": 0.2
+    },
+    {
+      "task": "arxiv_mc_2410",
+      "metric": "acc_stderr",
+      "value": 0.04020151261036846
+    },
+    {
+      "task": "arxiv_mc_2410",
+      "metric": "acc_norm",
+      "value": 0.23
+    },
+    {
+      "task": "arxiv_mc_2410",
+      "metric": "acc_norm_stderr",
+      "value": 0.042295258468165044
+    },
+    {
+      "task": "arxiv_mc_2411",
+      "metric": "acc",
+      "value": 0.24
+    },
+    {
+      "task": "arxiv_mc_2411",
+      "metric": "acc_stderr",
+      "value": 0.04292346959909282
+    },
+    {
+      "task": "arxiv_mc_2411",
+      "metric": "acc_norm",
+      "value": 0.34
+    },
+    {
+      "task": "arxiv_mc_2411",
+      "metric": "acc_norm_stderr",
+      "value": 0.04760952285695235
+    },
+    {
+      "task": "arxiv_mc_2412",
+      "metric": "acc",
+      "value": 0.11
+    },
+    {
+      "task": "arxiv_mc_2412",
+      "metric": "acc_stderr",
+      "value": 0.031446603773522035
+    },
+    {
+      "task": "arxiv_mc_2412",
+      "metric": "acc_norm",
+      "value": 0.23
+    },
+    {
+      "task": "arxiv_mc_2412",
+      "metric": "acc_norm_stderr",
+      "value": 0.04229525846816506
+    },
+    {
+      "task": "arxiv_mc_2501",
+      "metric": "acc",
+      "value": 0.14
+    },
+    {
+      "task": "arxiv_mc_2501",
+      "metric": "acc_stderr",
+      "value": 0.03487350880197771
+    },
+    {
+      "task": "arxiv_mc_2501",
+      "metric": "acc_norm",
+      "value": 0.24
+    },
+    {
+      "task": "arxiv_mc_2501",
+      "metric": "acc_norm_stderr",
+      "value": 0.04292346959909284
+    },
+    {
+      "task": "arxiv_mc_2502",
+      "metric": "acc",
+      "value": 0.14
+    },
+    {
+      "task": "arxiv_mc_2502",
+      "metric": "acc_stderr",
+      "value": 0.034873508801977704
+    },
+    {
+      "task": "arxiv_mc_2502",
+      "metric": "acc_norm",
+      "value": 0.2
+    },
+    {
+      "task": "arxiv_mc_2502",
+      "metric": "acc_norm_stderr",
+      "value": 0.040201512610368445
+    },
+    {
+      "task": "arxiv_mc_2503",
+      "metric": "acc",
+      "value": 0.17
+    },
+    {
+      "task": "arxiv_mc_2503",
+      "metric": "acc_stderr",
+      "value": 0.0377525168068637
+    },
+    {
+      "task": "arxiv_mc_2503",
+      "metric": "acc_norm",
+      "value": 0.2
+    },
+    {
+      "task": "arxiv_mc_2503",
+      "metric": "acc_norm_stderr",
+      "value": 0.04020151261036843
+    },
+    {
+      "task": "arxiv_mc_2504",
+      "metric": "acc",
+      "value": 0.15
+    },
+    {
+      "task": "arxiv_mc_2504",
+      "metric": "acc_stderr",
+      "value": 0.035887028128263734
+    },
+    {
+      "task": "arxiv_mc_2504",
+      "metric": "acc_norm",
+      "value": 0.17
+    },
+    {
+      "task": "arxiv_mc_2504",
+      "metric": "acc_norm_stderr",
+      "value": 0.0377525168068637
+    },
+    {
+      "task": "arxiv_mc_2505",
+      "metric": "acc",
+      "value": 0.19
+    },
+    {
+      "task": "arxiv_mc_2505",
+      "metric": "acc_stderr",
+      "value": 0.03942772444036623
+    },
+    {
+      "task": "arxiv_mc_2505",
+      "metric": "acc_norm",
+      "value": 0.24
+    },
+    {
+      "task": "arxiv_mc_2505",
+      "metric": "acc_norm_stderr",
+      "value": 0.042923469599092816
+    },
+    {
+      "task": "arxiv_mc_2506",
+      "metric": "acc",
+      "value": 0.15
+    },
+    {
+      "task": "arxiv_mc_2506",
+      "metric": "acc_stderr",
+      "value": 0.03588702812826371
+    },
+    {
+      "task": "arxiv_mc_2506",
+      "metric": "acc_norm",
+      "value": 0.27
+    },
+    {
+      "task": "arxiv_mc_2506",
+      "metric": "acc_norm_stderr",
+      "value": 0.0446196043338474
+    }
+  ],
+  "groups": [
+    {
+      "group": "arxiv_mc",
+      "metric": "acc",
+      "value": 0.16583333333333333
+    },
+    {
+      "group": "arxiv_mc",
+      "metric": "acc_stderr",
+      "value": 0.01074491240245708
+    },
+    {
+      "group": "arxiv_mc",
+      "metric": "acc_norm",
+      "value": 0.23916666666666667
+    },
+    {
+      "group": "arxiv_mc",
+      "metric": "acc_norm_stderr",
+      "value": 0.012288331311441483
+    }
+  ]
+}

out/eval/tinyllama_full_ppl/2407_full/ppl_metrics.jsonl

@@ -0,0 +1,48 @@
+{"month": "2407", "val_loss": 1.3401238918304443, "val_ppl": 3.8195166829675764, "rank": 2}
+{"month": "2407", "val_loss": 1.3308329582214355, "val_ppl": 3.784194150788953, "rank": 1}
+{"month": "2407", "val_loss": 1.4430962800979614, "val_ppl": 4.23378452615237, "rank": 3}
+{"month": "2407", "val_loss": 1.3418890237808228, "val_ppl": 3.826264587618703, "rank": 0}
+{"month": "2408", "val_loss": 1.4649615287780762, "val_ppl": 4.327376757626807, "rank": 2}
+{"month": "2408", "val_loss": 1.4553765058517456, "val_ppl": 4.286096902413764, "rank": 1}
+{"month": "2408", "val_loss": 1.4550942182540894, "val_ppl": 4.284887161171367, "rank": 3}
+{"month": "2408", "val_loss": 1.4382472038269043, "val_ppl": 4.213304277344344, "rank": 0}
+{"month": "2409", "val_loss": 1.4172937870025635, "val_ppl": 4.125939646771969, "rank": 2}
+{"month": "2409", "val_loss": 1.470693588256836, "val_ppl": 4.352252765856388, "rank": 1}
+{"month": "2409", "val_loss": 1.4720611572265625, "val_ppl": 4.35820884343254, "rank": 3}
+{"month": "2409", "val_loss": 1.4188635349273682, "val_ppl": 4.132421418012854, "rank": 0}
+{"month": "2410", "val_loss": 1.3499130010604858, "val_ppl": 3.8570899533641967, "rank": 2}
+{"month": "2410", "val_loss": 1.3595799207687378, "val_ppl": 3.894556935633931, "rank": 1}
+{"month": "2410", "val_loss": 1.4495704174041748, "val_ppl": 4.261283548672918, "rank": 3}
+{"month": "2410", "val_loss": 1.5745606422424316, "val_ppl": 4.828619660488959, "rank": 0}
+{"month": "2411", "val_loss": 1.4264885187149048, "val_ppl": 4.164051500513005, "rank": 2}
+{"month": "2411", "val_loss": 1.4281030893325806, "val_ppl": 4.170780086142855, "rank": 1}
+{"month": "2411", "val_loss": 1.4030014276504517, "val_ppl": 4.067389640213666, "rank": 3}
+{"month": "2411", "val_loss": 1.4369604587554932, "val_ppl": 4.207886315346613, "rank": 0}
+{"month": "2412", "val_loss": 1.4747017621994019, "val_ppl": 4.369732359207785, "rank": 1}
+{"month": "2412", "val_loss": 1.408434271812439, "val_ppl": 4.089547269247822, "rank": 3}
+{"month": "2412", "val_loss": 1.411298155784607, "val_ppl": 4.1012760450356875, "rank": 2}
+{"month": "2412", "val_loss": 1.4237630367279053, "val_ppl": 4.152717904926461, "rank": 0}
+{"month": "2501", "val_loss": 1.3047839403152466, "val_ppl": 3.6868924188297223, "rank": 1}
+{"month": "2501", "val_loss": 1.4822993278503418, "val_ppl": 4.403058124724474, "rank": 2}
+{"month": "2501", "val_loss": 1.355212688446045, "val_ppl": 3.8775855865882565, "rank": 3}
+{"month": "2501", "val_loss": 1.4138273000717163, "val_ppl": 4.111661892031496, "rank": 0}
+{"month": "2502", "val_loss": 1.3723409175872803, "val_ppl": 3.944573818198906, "rank": 1}
+{"month": "2502", "val_loss": 1.4143813848495483, "val_ppl": 4.113940732574589, "rank": 2}
+{"month": "2502", "val_loss": 1.421377182006836, "val_ppl": 4.142821933177419, "rank": 3}
+{"month": "2502", "val_loss": 1.404603362083435, "val_ppl": 4.073910553373853, "rank": 0}
+{"month": "2503", "val_loss": 1.426881194114685, "val_ppl": 4.165686942178515, "rank": 1}
+{"month": "2503", "val_loss": 1.438934326171875, "val_ppl": 4.216200327715984, "rank": 2}
+{"month": "2503", "val_loss": 1.4343088865280151, "val_ppl": 4.196743580268452, "rank": 3}
+{"month": "2503", "val_loss": 1.456992745399475, "val_ppl": 4.293029862886088, "rank": 0}
+{"month": "2504", "val_loss": 1.4529080390930176, "val_ppl": 4.275529862244869, "rank": 2}
+{"month": "2504", "val_loss": 1.4284093379974365, "val_ppl": 4.172057577580683, "rank": 3}
+{"month": "2504", "val_loss": 1.4099334478378296, "val_ppl": 4.095682818453564, "rank": 1}
+{"month": "2504", "val_loss": 1.4458612203598022, "val_ppl": 4.245506885792738, "rank": 0}
+{"month": "2505", "val_loss": 1.4609925746917725, "val_ppl": 4.3102356366241965, "rank": 2}
+{"month": "2505", "val_loss": 1.4186663627624512, "val_ppl": 4.131606699858025, "rank": 3}
+{"month": "2505", "val_loss": 1.4786559343338013, "val_ppl": 4.387045239634099, "rank": 1}
+{"month": "2505", "val_loss": 1.4452773332595825, "val_ppl": 4.243028712645302, "rank": 0}
+{"month": "2506", "val_loss": 1.4663327932357788, "val_ppl": 4.333314805956465, "rank": 2}
+{"month": "2506", "val_loss": 1.3949086666107178, "val_ppl": 4.0346060615577555, "rank": 3}
+{"month": "2506", "val_loss": 1.4446309804916382, "val_ppl": 4.240287105410576, "rank": 1}
+{"month": "2506", "val_loss": 1.443738341331482, "val_ppl": 4.23650374792772, "rank": 0}

out/eval/tinyllama_full_ppl/2408_full/ppl_metrics.jsonl

@@ -0,0 +1,48 @@
+{"month": "2407", "val_loss": 1.362528920173645, "val_ppl": 3.906058933075612, "rank": 2}
+{"month": "2407", "val_loss": 1.4777755737304688, "val_ppl": 4.3831847573976574, "rank": 3}
+{"month": "2407", "val_loss": 1.3729832172393799, "val_ppl": 3.9471082304289324, "rank": 0}
+{"month": "2407", "val_loss": 1.3674103021621704, "val_ppl": 3.9251725111825952, "rank": 1}
+{"month": "2408", "val_loss": 1.2508023977279663, "val_ppl": 3.4931447246362146, "rank": 2}
+{"month": "2408", "val_loss": 1.2579619884490967, "val_ppl": 3.5182439540845136, "rank": 3}
+{"month": "2408", "val_loss": 1.2399872541427612, "val_ppl": 3.4555694202874743, "rank": 0}
+{"month": "2408", "val_loss": 1.2464643716812134, "val_ppl": 3.478024192179584, "rank": 1}
+{"month": "2409", "val_loss": 1.4675408601760864, "val_ppl": 4.338552903664771, "rank": 3}
+{"month": "2409", "val_loss": 1.4120129346847534, "val_ppl": 4.104208598555189, "rank": 2}
+{"month": "2409", "val_loss": 1.4647713899612427, "val_ppl": 4.326554033548489, "rank": 1}
+{"month": "2409", "val_loss": 1.4133905172348022, "val_ppl": 4.109866380838644, "rank": 0}
+{"month": "2410", "val_loss": 1.4405683279037476, "val_ppl": 4.223095237966944, "rank": 3}
+{"month": "2410", "val_loss": 1.3448939323425293, "val_ppl": 3.8377794547343513, "rank": 2}
+{"month": "2410", "val_loss": 1.3568646907806396, "val_ppl": 3.883996661126899, "rank": 1}
+{"month": "2410", "val_loss": 1.573472261428833, "val_ppl": 4.823367142382782, "rank": 0}
+{"month": "2411", "val_loss": 1.3975845575332642, "val_ppl": 4.045416684867629, "rank": 3}
+{"month": "2411", "val_loss": 1.4199227094650269, "val_ppl": 4.1368006923562195, "rank": 2}
+{"month": "2411", "val_loss": 1.4218403100967407, "val_ppl": 4.144741034746768, "rank": 1}
+{"month": "2411", "val_loss": 1.4330910444259644, "val_ppl": 4.1916357201597405, "rank": 0}
+{"month": "2412", "val_loss": 1.4037216901779175, "val_ppl": 4.070320283845813, "rank": 3}
+{"month": "2412", "val_loss": 1.4028061628341675, "val_ppl": 4.066595499659191, "rank": 2}
+{"month": "2412", "val_loss": 1.4695839881896973, "val_ppl": 4.347426184178079, "rank": 1}
+{"month": "2412", "val_loss": 1.417596459388733, "val_ppl": 4.1271886437789655, "rank": 0}
+{"month": "2501", "val_loss": 1.3509228229522705, "val_ppl": 3.8609868945147734, "rank": 3}
+{"month": "2501", "val_loss": 1.2983866930007935, "val_ppl": 3.663381738204649, "rank": 1}
+{"month": "2501", "val_loss": 1.476736307144165, "val_ppl": 4.378631826202121, "rank": 2}
+{"month": "2501", "val_loss": 1.4069976806640625, "val_ppl": 4.083676479811697, "rank": 0}
+{"month": "2502", "val_loss": 1.4095300436019897, "val_ppl": 4.094030935866561, "rank": 2}
+{"month": "2502", "val_loss": 1.4141857624053955, "val_ppl": 4.113136032144681, "rank": 3}
+{"month": "2502", "val_loss": 1.3664177656173706, "val_ppl": 3.9212785667813335, "rank": 1}
+{"month": "2502", "val_loss": 1.3973371982574463, "val_ppl": 4.044416137278543, "rank": 0}
+{"month": "2503", "val_loss": 1.4294711351394653, "val_ppl": 4.1764898090418745, "rank": 2}
+{"month": "2503", "val_loss": 1.4288697242736816, "val_ppl": 4.1739787778462905, "rank": 3}
+{"month": "2503", "val_loss": 1.419816255569458, "val_ppl": 4.136360337246501, "rank": 1}
+{"month": "2503", "val_loss": 1.4511704444885254, "val_ppl": 4.2681071753028474, "rank": 0}
+{"month": "2504", "val_loss": 1.4489697217941284, "val_ppl": 4.2587245830087355, "rank": 2}
+{"month": "2504", "val_loss": 1.4048845767974854, "val_ppl": 4.075056358066205, "rank": 1}
+{"month": "2504", "val_loss": 1.4212480783462524, "val_ppl": 4.142287114224986, "rank": 3}
+{"month": "2504", "val_loss": 1.4392225742340088, "val_ppl": 4.21741581446245, "rank": 0}
+{"month": "2505", "val_loss": 1.417108178138733, "val_ppl": 4.125173906868153, "rank": 3}
+{"month": "2505", "val_loss": 1.454293131828308, "val_ppl": 4.2814559707540765, "rank": 2}
+{"month": "2505", "val_loss": 1.47247314453125, "val_ppl": 4.360004740065115, "rank": 1}
+{"month": "2505", "val_loss": 1.438664197921753, "val_ppl": 4.215061566711977, "rank": 0}
+{"month": "2506", "val_loss": 1.3888366222381592, "val_ppl": 4.010181981617138, "rank": 3}
+{"month": "2506", "val_loss": 1.460412859916687, "val_ppl": 4.307737653470374, "rank": 2}
+{"month": "2506", "val_loss": 1.4377959966659546, "val_ppl": 4.211403633107536, "rank": 1}
+{"month": "2506", "val_loss": 1.438284993171692, "val_ppl": 4.2134634983607855, "rank": 0}

out/eval/tinyllama_full_ppl/2409_full/ppl_metrics.jsonl

@@ -0,0 +1,48 @@
+{"month": "2407", "val_loss": 1.485063910484314, "val_ppl": 4.415247584373104, "rank": 3}
+{"month": "2407", "val_loss": 1.3649768829345703, "val_ppl": 3.915632533012995, "rank": 2}
+{"month": "2407", "val_loss": 1.3764039278030396, "val_ppl": 3.9606332646741, "rank": 1}
+{"month": "2407", "val_loss": 1.379693627357483, "val_ppl": 3.97368401291081, "rank": 0}
+{"month": "2408", "val_loss": 1.3427562713623047, "val_ppl": 3.8295843456464147, "rank": 2}
+{"month": "2408", "val_loss": 1.3247745037078857, "val_ppl": 3.7613370917958093, "rank": 3}
+{"month": "2408", "val_loss": 1.3265122175216675, "val_ppl": 3.7678789014688667, "rank": 0}
+{"month": "2408", "val_loss": 1.31806480884552, "val_ppl": 3.7361841462953675, "rank": 1}
+{"month": "2409", "val_loss": 1.2037886381149292, "val_ppl": 3.332719502488496, "rank": 2}
+{"month": "2409", "val_loss": 1.261081337928772, "val_ppl": 3.5292357212007732, "rank": 1}
+{"month": "2409", "val_loss": 1.2550549507141113, "val_ppl": 3.508031137862438, "rank": 3}
+{"month": "2409", "val_loss": 1.2141947746276855, "val_ppl": 3.367581310364588, "rank": 0}
+{"month": "2410", "val_loss": 1.3304420709609985, "val_ppl": 3.78271524656563, "rank": 2}
+{"month": "2410", "val_loss": 1.4265085458755493, "val_ppl": 4.164134895476417, "rank": 3}
+{"month": "2410", "val_loss": 1.3427306413650513, "val_ppl": 3.829486194667964, "rank": 1}
+{"month": "2410", "val_loss": 1.5633049011230469, "val_ppl": 4.774574696275717, "rank": 0}
+{"month": "2411", "val_loss": 1.3834478855133057, "val_ppl": 3.9886302870557864, "rank": 3}
+{"month": "2411", "val_loss": 1.4033945798873901, "val_ppl": 4.0689890579359425, "rank": 2}
+{"month": "2411", "val_loss": 1.4083776473999023, "val_ppl": 4.089315707592243, "rank": 1}
+{"month": "2411", "val_loss": 1.4190096855163574, "val_ppl": 4.133025417973448, "rank": 0}
+{"month": "2412", "val_loss": 1.3886818885803223, "val_ppl": 4.009561519494955, "rank": 2}
+{"month": "2412", "val_loss": 1.3894152641296387, "val_ppl": 4.012503112391143, "rank": 3}
+{"month": "2412", "val_loss": 1.4546624422073364, "val_ppl": 4.2830374488916, "rank": 1}
+{"month": "2412", "val_loss": 1.4025143384933472, "val_ppl": 4.065408941249854, "rank": 0}
+{"month": "2501", "val_loss": 1.4628865718841553, "val_ppl": 4.318406946594848, "rank": 2}
+{"month": "2501", "val_loss": 1.3351476192474365, "val_ppl": 3.8005569403668753, "rank": 3}
+{"month": "2501", "val_loss": 1.2839248180389404, "val_ppl": 3.610783619993481, "rank": 1}
+{"month": "2501", "val_loss": 1.3923919200897217, "val_ppl": 4.024464747699859, "rank": 0}
+{"month": "2502", "val_loss": 1.3984625339508057, "val_ppl": 4.048970024962219, "rank": 3}
+{"month": "2502", "val_loss": 1.351839303970337, "val_ppl": 3.8645270377038248, "rank": 1}
+{"month": "2502", "val_loss": 1.3960250616073608, "val_ppl": 4.039112790755192, "rank": 2}
+{"month": "2502", "val_loss": 1.383058786392212, "val_ppl": 3.987078616413143, "rank": 0}
+{"month": "2503", "val_loss": 1.4119216203689575, "val_ppl": 4.1038338426656775, "rank": 3}
+{"month": "2503", "val_loss": 1.4145982265472412, "val_ppl": 4.114832903193648, "rank": 2}
+{"month": "2503", "val_loss": 1.4040486812591553, "val_ppl": 4.0716514599059, "rank": 1}
+{"month": "2503", "val_loss": 1.4355839490890503, "val_ppl": 4.202098103836741, "rank": 0}
+{"month": "2504", "val_loss": 1.407296895980835, "val_ppl": 4.084898561186815, "rank": 3}
+{"month": "2504", "val_loss": 1.4341951608657837, "val_ppl": 4.196266329963888, "rank": 2}
+{"month": "2504", "val_loss": 1.3897756338119507, "val_ppl": 4.013949357438815, "rank": 1}
+{"month": "2504", "val_loss": 1.423025131225586, "val_ppl": 4.149654721843654, "rank": 0}
+{"month": "2505", "val_loss": 1.4383201599121094, "val_ppl": 4.213611674743316, "rank": 2}
+{"month": "2505", "val_loss": 1.406368374824524, "val_ppl": 4.081107406807272, "rank": 3}
+{"month": "2505", "val_loss": 1.454991102218628, "val_ppl": 4.284445343374549, "rank": 1}
+{"month": "2505", "val_loss": 1.4232839345932007, "val_ppl": 4.150728805442337, "rank": 0}
+{"month": "2506", "val_loss": 1.443969964981079, "val_ppl": 4.237485136039307, "rank": 2}
+{"month": "2506", "val_loss": 1.3735177516937256, "val_ppl": 3.9492186597714762, "rank": 3}
+{"month": "2506", "val_loss": 1.4226653575897217, "val_ppl": 4.148162054004164, "rank": 1}
+{"month": "2506", "val_loss": 1.4236834049224854, "val_ppl": 4.152387229668601, "rank": 0}

out/eval/tinyllama_full_ppl/2410_full/ppl_metrics.jsonl

@@ -0,0 +1,48 @@
+{"month": "2407", "val_loss": 1.3625130653381348, "val_ppl": 3.9059970036446767, "rank": 2}
+{"month": "2407", "val_loss": 1.4842785596847534, "val_ppl": 4.4117814274051845, "rank": 3}
+{"month": "2407", "val_loss": 1.377859115600586, "val_ppl": 3.9664009253683554, "rank": 1}
+{"month": "2407", "val_loss": 1.3787990808486938, "val_ppl": 3.9701309571737657, "rank": 0}
+{"month": "2408", "val_loss": 1.343483805656433, "val_ppl": 3.832371513347234, "rank": 3}
+{"month": "2408", "val_loss": 1.3664422035217285, "val_ppl": 3.921374395782834, "rank": 2}
+{"month": "2408", "val_loss": 1.344637393951416, "val_ppl": 3.836795043242655, "rank": 1}
+{"month": "2408", "val_loss": 1.3435213565826416, "val_ppl": 3.832515425149129, "rank": 0}
+{"month": "2409", "val_loss": 1.2931017875671387, "val_ppl": 3.6440721816842823, "rank": 2}
+{"month": "2409", "val_loss": 1.3426209688186646, "val_ppl": 3.829066228195459, "rank": 3}
+{"month": "2409", "val_loss": 1.3356683254241943, "val_ppl": 3.80253642916214, "rank": 1}
+{"month": "2409", "val_loss": 1.298521876335144, "val_ppl": 3.663876999837824, "rank": 0}
+{"month": "2410", "val_loss": 1.1201715469360352, "val_ppl": 3.065380014740353, "rank": 1}
+{"month": "2410", "val_loss": 1.2227020263671875, "val_ppl": 3.3963523801706224, "rank": 3}
+{"month": "2410", "val_loss": 1.1426008939743042, "val_ppl": 3.1349113431069515, "rank": 2}
+{"month": "2410", "val_loss": 1.3279122114181519, "val_ppl": 3.7731576031464997, "rank": 0}
+{"month": "2411", "val_loss": 1.3699663877487183, "val_ppl": 3.935218421697037, "rank": 3}
+{"month": "2411", "val_loss": 1.3956365585327148, "val_ppl": 4.0375438877986864, "rank": 1}
+{"month": "2411", "val_loss": 1.3899426460266113, "val_ppl": 4.014619791994358, "rank": 2}
+{"month": "2411", "val_loss": 1.4060338735580444, "val_ppl": 4.079742499505393, "rank": 0}
+{"month": "2412", "val_loss": 1.3763186931610107, "val_ppl": 3.9602956959020594, "rank": 3}
+{"month": "2412", "val_loss": 1.3741707801818848, "val_ppl": 3.951798454310262, "rank": 2}
+{"month": "2412", "val_loss": 1.4407111406326294, "val_ppl": 4.223698392790274, "rank": 1}
+{"month": "2412", "val_loss": 1.3878103494644165, "val_ppl": 4.006068552143023, "rank": 0}
+{"month": "2501", "val_loss": 1.2720528841018677, "val_ppl": 3.5681700884164584, "rank": 1}
+{"month": "2501", "val_loss": 1.4463121891021729, "val_ppl": 4.247421908468978, "rank": 2}
+{"month": "2501", "val_loss": 1.3237147331237793, "val_ppl": 3.7573530488476545, "rank": 3}
+{"month": "2501", "val_loss": 1.3789067268371582, "val_ppl": 3.970558348848071, "rank": 0}
+{"month": "2502", "val_loss": 1.3828585147857666, "val_ppl": 3.9862801977265754, "rank": 3}
+{"month": "2502", "val_loss": 1.3822216987609863, "val_ppl": 3.983742478733221, "rank": 2}
+{"month": "2502", "val_loss": 1.336174726486206, "val_ppl": 3.8044625252956084, "rank": 1}
+{"month": "2502", "val_loss": 1.3672521114349365, "val_ppl": 3.9245516343983025, "rank": 0}
+{"month": "2503", "val_loss": 1.3872737884521484, "val_ppl": 4.003919628511345, "rank": 1}
+{"month": "2503", "val_loss": 1.3932018280029297, "val_ppl": 4.0277255138273516, "rank": 2}
+{"month": "2503", "val_loss": 1.3974146842956543, "val_ppl": 4.04472953520371, "rank": 3}
+{"month": "2503", "val_loss": 1.4191503524780273, "val_ppl": 4.133606838993904, "rank": 0}
+{"month": "2504", "val_loss": 1.4196085929870605, "val_ppl": 4.1355014591586485, "rank": 2}
+{"month": "2504", "val_loss": 1.3901379108428955, "val_ppl": 4.0154037825308855, "rank": 3}
+{"month": "2504", "val_loss": 1.3766632080078125, "val_ppl": 3.961660311618713, "rank": 1}
+{"month": "2504", "val_loss": 1.40700101852417, "val_ppl": 4.083690110575259, "rank": 0}
+{"month": "2505", "val_loss": 1.4231395721435547, "val_ppl": 4.150129639313753, "rank": 2}
+{"month": "2505", "val_loss": 1.391589879989624, "val_ppl": 4.021238259650132, "rank": 3}
+{"month": "2505", "val_loss": 1.4063525199890137, "val_ppl": 4.081042702033581, "rank": 0}
+{"month": "2505", "val_loss": 1.4384384155273438, "val_ppl": 4.214109987447828, "rank": 1}
+{"month": "2506", "val_loss": 1.4291367530822754, "val_ppl": 4.175093499251175, "rank": 2}
+{"month": "2506", "val_loss": 1.357244849205017, "val_ppl": 3.885473475871877, "rank": 3}
+{"month": "2506", "val_loss": 1.4066842794418335, "val_ppl": 4.082396851140804, "rank": 1}
+{"month": "2506", "val_loss": 1.4085280895233154, "val_ppl": 4.089930959209319, "rank": 0}

out/eval/tinyllama_full_ppl/2411_full/ppl_metrics.jsonl

@@ -0,0 +1,48 @@
+{"month": "2407", "val_loss": 1.4872686862945557, "val_ppl": 4.424992954673992, "rank": 3}
+{"month": "2407", "val_loss": 1.3803930282592773, "val_ppl": 3.9764641832063625, "rank": 1}
+{"month": "2407", "val_loss": 1.380758285522461, "val_ppl": 3.9779168809191128, "rank": 0}
+{"month": "2407", "val_loss": 1.3626710176467896, "val_ppl": 3.906614013616793, "rank": 2}
+{"month": "2408", "val_loss": 1.3559932708740234, "val_ppl": 3.88061354339132, "rank": 1}
+{"month": "2408", "val_loss": 1.353184461593628, "val_ppl": 3.869728933609592, "rank": 3}
+{"month": "2408", "val_loss": 1.3515592813491821, "val_ppl": 3.8634450342130005, "rank": 0}
+{"month": "2408", "val_loss": 1.377118468284607, "val_ppl": 3.963464308801716, "rank": 2}
+{"month": "2409", "val_loss": 1.3564050197601318, "val_ppl": 3.8822117106944525, "rank": 1}
+{"month": "2409", "val_loss": 1.313551425933838, "val_ppl": 3.7193593136317187, "rank": 2}
+{"month": "2409", "val_loss": 1.3636155128479004, "val_ppl": 3.910305534842863, "rank": 3}
+{"month": "2409", "val_loss": 1.317995309829712, "val_ppl": 3.735924494197209, "rank": 0}
+{"month": "2410", "val_loss": 1.1867964267730713, "val_ppl": 3.2765676514970967, "rank": 1}
+{"month": "2410", "val_loss": 1.307090163230896, "val_ppl": 3.695405026826404, "rank": 3}
+{"month": "2410", "val_loss": 1.220895767211914, "val_ppl": 3.3902232246774173, "rank": 2}
+{"month": "2410", "val_loss": 1.3971407413482666, "val_ppl": 4.043621661827428, "rank": 0}
+{"month": "2411", "val_loss": 1.1956223249435425, "val_ppl": 3.305614296752107, "rank": 1}
+{"month": "2411", "val_loss": 1.1755108833312988, "val_ppl": 3.239797679744836, "rank": 3}
+{"month": "2411", "val_loss": 1.1895569562911987, "val_ppl": 3.2856252092930816, "rank": 2}
+{"month": "2411", "val_loss": 1.2081102132797241, "val_ppl": 3.3471532661552215, "rank": 0}
+{"month": "2412", "val_loss": 1.4345154762268066, "val_ppl": 4.197610673823818, "rank": 1}
+{"month": "2412", "val_loss": 1.3702863454818726, "val_ppl": 3.9364777267141564, "rank": 3}
+{"month": "2412", "val_loss": 1.366951823234558, "val_ppl": 3.9233733147773107, "rank": 2}
+{"month": "2412", "val_loss": 1.3812273740768433, "val_ppl": 3.979783313925192, "rank": 0}
+{"month": "2501", "val_loss": 1.2640061378479004, "val_ppl": 3.539573139623763, "rank": 1}
+{"month": "2501", "val_loss": 1.3158841133117676, "val_ppl": 3.7280455433470294, "rank": 3}
+{"month": "2501", "val_loss": 1.4420026540756226, "val_ppl": 4.229156880139874, "rank": 2}
+{"month": "2501", "val_loss": 1.3726694583892822, "val_ppl": 3.945869984554801, "rank": 0}
+{"month": "2502", "val_loss": 1.3292156457901, "val_ppl": 3.7780788730366375, "rank": 1}
+{"month": "2502", "val_loss": 1.3757652044296265, "val_ppl": 3.958104323367374, "rank": 3}
+{"month": "2502", "val_loss": 1.37555992603302, "val_ppl": 3.9572918934482804, "rank": 2}
+{"month": "2502", "val_loss": 1.3592376708984375, "val_ppl": 3.8932242520962257, "rank": 0}
+{"month": "2503", "val_loss": 1.382246494293213, "val_ppl": 3.9838412589728835, "rank": 1}
+{"month": "2503", "val_loss": 1.3877980709075928, "val_ppl": 4.006019363704648, "rank": 2}
+{"month": "2503", "val_loss": 1.3916492462158203, "val_ppl": 4.021476992476507, "rank": 3}
+{"month": "2503", "val_loss": 1.413512110710144, "val_ppl": 4.110366144158445, "rank": 0}
+{"month": "2504", "val_loss": 1.3709253072738647, "val_ppl": 3.938993789324889, "rank": 1}
+{"month": "2504", "val_loss": 1.3838448524475098, "val_ppl": 3.99021395570376, "rank": 3}
+{"month": "2504", "val_loss": 1.412560224533081, "val_ppl": 4.1064554050277025, "rank": 2}
+{"month": "2504", "val_loss": 1.4007281064987183, "val_ppl": 4.058153659465043, "rank": 0}
+{"month": "2505", "val_loss": 1.4315732717514038, "val_ppl": 4.1852785955573495, "rank": 1}
+{"month": "2505", "val_loss": 1.3883154392242432, "val_ppl": 4.008092487437342, "rank": 3}
+{"month": "2505", "val_loss": 1.4160114526748657, "val_ppl": 4.120652203588402, "rank": 2}
+{"month": "2505", "val_loss": 1.40048086643219, "val_ppl": 4.057150445306773, "rank": 0}
+{"month": "2506", "val_loss": 1.399654507637024, "val_ppl": 4.053799168222336, "rank": 1}
+{"month": "2506", "val_loss": 1.3464387655258179, "val_ppl": 3.843712765593928, "rank": 3}
+{"month": "2506", "val_loss": 1.41997492313385, "val_ppl": 4.137016695536668, "rank": 2}
+{"month": "2506", "val_loss": 1.4047600030899048, "val_ppl": 4.07454874480537, "rank": 0}